Introducing Julia/Types

From Wikibooks, open books for an open world
Jump to: navigation, search
« Introducing Julia
Arrays and tuples Controlling the flow


This section, on types, and the next section, on functions and methods, should ideally be read at the same time, because the two topics are so closely connected.

Types of type[edit]

Data elements come in different shapes and sizes, which are called types.

Consider the following numeric values: a floating point number, a rational number, and an integer:

0.5  1//2  1

It's easy for us humans to add these numbers without much thought, but a computer won't be able to use a simple addition routine to add all three values, because the types are different. Code for adding rational numbers has to consider numerators and denominators, whereas code for adding integers won't. The computer will probably have to convert two of these values to be the same type as the third—typically the integer and the rational will first be converted to floating-point—then the three floating-point numbers will be added together.

This business of converting types obviously takes time. So, to write really fast code, you want to make sure that you don't make the computer waste time by continually converting values from one type to another. When Julia compiles your source code (which happens every time you evaluate a function for the first time), any type indications you've provided allow the compiler to produce more efficient executable code.

Another issue with converting types is that in some cases you'll be losing precision—converting a rational number to a floating-point number is likely to lose some precision.

The official word from the designers of Julia is that types are optional. In other words, if you don't want to worry about types (and if you don't mind your code running slower than it might), then you can ignore them. But you'll encounter them in error messages and the documentation, so you will eventually have to tackle them…

A compromise is to write your top-level code without worrying about types, but, when you want to speed up your code, find out the bottlenecks where your program spends the most time, and clean up the types in that area.

The type system[edit]

There's a lot to know about Julia's type system, so the official documentation is really the place to go. But here's a brief overview.

Type hierarchy[edit]

In Julia types are organized in an hierarchical way, and this hierarchy has a tree structure. (Note, however, hierarchical relationships between types are explicitly declared, rather than implied by compatible structure.) At the tree's root, we have a special type called Any, and all other types are connected to it directly or indirectly. Informally, we can say that the type Any has children. Its children are called Any's subtypes. Alternatively, we say that a child's supertype is Any.

An example of that is the type Number, a direct child of Any. To see what Number's supertype is, we can use the supertype() function (super() for Julia < v0.5):

julia> supertype(Number)

But if we were curious, we could also try to find Number's subtypes (Number's children, therefore Any's grandchildren). To do this, we can use the function subtypes():

julia> subtypes(Number)
2-element Array{Union{DataType, UnionAll},1}:

Despite the syntactical junk, we can observe that we have two subtypes of Number: Complex and Real. If we knew maths, we could check that, for mathematicians, real and complex are both, indeed, numbers. Here is a general rule: Julia type's hierarchy reflect the real world's hierarchy.

type hierarchy for julia numbers

As another example, if both Jaguar and Lion were Julia types, it would natural if their supertype were Feline. We would have:

julia> abstract type Feline end
julia> type Jaguar <: Feline end
julia> type Lion <: Feline end
julia> subtypes(Feline)
2-element Array{Any,1}:

Concrete and abstract types[edit]

Each object in Julia (informally, this mean everything you can put into a variable in Julia) has a type. But not all types can have a respective object (instances of that type). The only ones that can have instances are called concrete types. These types cannot have any subtypes. The types that can have subtypes (e.g. Any, Number) are called abstract types. Therefore we cannot have a object of type Number, since it's an abstract type. In other words, only the leaves of the type tree are concrete types and can be instantiated.

If we can't create objects of abstract types, why are they useful? With them, we can write code that generalizes for any of its subtypes. For instance, suppose we write a function that expects a variable of the type Number:

#this function gets a number, and returns the same number plus one
function plus_one(n::Number)
 return n + 1

In this example, the function expects a variable n. The type of n must be subtype of Number (directly or indirectly) as indicated with the :: syntax (but don't worry about the syntax yet). What does this mean? No matter if n's type is Int (Integer number) or Float64 (floating-point number), the function plus_one() will work correctly. Furthermore, plus_one() will not work with any types that are not subtypes of Number (e.g. text strings, arrays).

We can divide concrete types into two categories: primitive (or basic), and complex (or composite). Primitive types are the building blocks, usually hardcoded into Julia's heart, whereas composite types group many other types to represent higher-level data structures.

You'll probably see the following primitive types:

  • the basic integer and float types (signed and unsigned): Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, Float16, Float32, and Float64
  • more advanced numeric types: BigFloat, BigInt
  • Boolean and character types: Bool and Char
  • Text string types: String

A simple example of a composite type is Rational, used to represent fractions. It is composed of two pieces, a numerator and a denominator, both integers (of type Int).

Investigating types[edit]

Julia provides two functions for navigating the type hierarchy: subtypes() and supertype().

julia> subtypes(Integer)
4-element Array{Union{DataType, UnionAll},1}:

julia> supertype(Float64)

The sizeof() function tells you how many bytes an item of this type occupies:

julia> sizeof(BigFloat)

julia> sizeof(Char)

If you want to know how big a number you can fit into a particular type, these two functions are useful:

julia> typemax(Int64)

julia> typemin(Int32)

There are over 340 types in the base Julia system. You can investigate the type hierarchy with the following function:

function showtypetree(T, level=0)
    println("\t" ^ level, T)
    for t in subtypes(T)
        if t != Any
            showtypetree(t, level+1)


It produces something like this for the different Number types:

julia> showtypetree(Number)

This shows, for example, the four main subtypes of Real number: AbstractFloat, Integer, Rational, and Irrational.

Specifying the type of variables[edit]

We've already seen that Julia likes to guess at the types of things you put in your code, if you don't specify them:

julia> collect(1:10)
10-element Array{Int64,1}:
julia> collect(1.0:10)
10-element Array{Float64,1}:

And we've also seen that you can specify the type for a new array:

julia> fill!(Array{String}(3), "Julia")
3-element Array{String,1}:

For variables, you can specify the type that its value must have. For technical reasons, you can't do this at the top level, in the REPL—you can only do it inside a definition. The syntax uses the :: syntax, which means "is of type". So:

function f(x::Int64)

means that the function f has a method that accepts an argument x which is expected to be an Int64. See Functions.

Type stability[edit]

Here's an example of how the performance of Julia code is affected by the choice of type for variables. Can you spot the difference between these two functions:

julia> function t1(n)
           s  = 0
           for i in 1:n
               s += s/i
t1 (generic function with 1 method)

julia> function t2(n)
           s  = 0.0
           for i in 1:n
               s += s/i
t2 (generic function with 1 method)

These two function definitions are almost identical, except for the type of s at the start of each one. After running them both a few times, the timing results are noteworthy:

julia> @time t1(10000000)
  0.679342 seconds (30.00 M allocations: 457.756 MB, 4.99% gc time)

julia>  @time t2(10000000)
  0.000002 seconds (4 allocations: 160 bytes)

The performance of t1() is significantly worse than that of t2(); it's slower and uses much more memory, and additional time is spent cleaning up ("gc" is the garbage collector). The reason is that s starts out as an integer (s = 0 means that Julia guessed that s was an integer), but inside the loop it's assigned to hold the result of s/i, which is a floating-point value: it has to be converted from integer to floating-point to match. So the function isn't 'type stable—the Julia compiler is unable to make assumptions about its contents, so it can't produce pure integer code or pure floating-point code. As a result, the code it ends up producing isn't as fast as it could be. (Run the commands @code_llvm t1(100) and @code_llvm t2(100) to see how much more work you've made the Julia compiler do...)

Creating types[edit]

In Julia, it's very easy for the programmer to create new types, benefiting from the same performance and language-wise integration that the native types (those made by Julia's creators) have.

Abstract types[edit]

Suppose we want to create an abstract type. To do this, we use Julia's keyword abstract followed by the name of the type you want to create:

abstract type MyAbstractType end

By default, the type you create is a direct subtype of Any:

julia> supertype(MyAbstractType)

You can change this using the <: operator. If you want your new abstract type to be a subtype of Number, for example, you can declare:

abstract type MyAbstractType2 <: Number end

Now, we get:

julia> supertype(MyAbstractType2)

Notice that in the same Julia session (without exiting the REPL or ending the script) it's impossible to redefine a type. That's why we had to create a type called MyAbstractType2. Another workaround is to restart Julia workspace using the workspace() function. This will start fresh the REPL section, but you will lose all libraries you imported and variables you stored.

Concrete types and composite[edit]

You can create new composite types. To do this, use the struct keyword, which has the same syntax as declaring the supertype. The new type can contain multiple fields, where the object stores values. As an example, let's define a concrete type that is a subtype of MyAbstractType:

struct MyType <: MyAbstractType

We just created a composite struct type called MyType, a subtype of MyAbstractType, with two fields: foo that can be of any type, and bar, that is of type Int.

How do we create an object of MyType? By default, Julia automatically creates a constructor, a function that returns an object of that type. The function has the same name of the type, and each argument of the function correspond to each field. In this example, we can create a new object by typing:

julia> x = MyType("Hello World!", 10)
 MyType("Hello World!", 10)

This creates a MyType object, assigning Hello World! to the foo field and 10 to the bar field. We can access x's fields by using the dot notation:

 "Hello World!"


Also, we can change the field's values of the object easily:

julia> = 3.0


Notice that, since we didn't specify foo's type when we created the type definition, we can change its type at any time. This is different when we try to change the type of the field (which we specified as being an Int according to MyType's definition):

julia> = "Hello World!"
LoadError: MethodError: Cannot `convert` an object of type String to an object of type Int64
This may have arisen from a call to the constructor Int64(...),
since type constructors fall back to convert methods.

The error message tells us that Julia couldn't change's type. This ensures type-stable code, and can provide better performance when programming. As a performance tip, specifying a field's type when possible is usually good practice.

The default constructor is used for simple cases, where you type something like typename(field1, field2) to produce a new instance of the type. But sometimes you want to do more when you construct a new instance, such as checking the incoming values. For this you can use an inner constructor, a function inside the type definition. The next section shows a practical example.

Example: British currency[edit]

Here's an example of how you can create a simple composite type that can handle the old-fashioned British currency. Before Britain saw the light and introduced a decimal currency, the monetary system used pounds, shillings, and pence, where a pound consisted of 20 shillings, and a shilling consisted of 12 pence. This was called the £sd or LSD system (Latin for Librae, Solidii, Denarii, because the system originated in the Roman empire).

To define a suitable type, start a new composite type declaration:

struct LSD

To contain a price in pounds, shillings, and pence, this new type should contain three fields: pounds, shillings, and pence:


The important task is to create a constructor function. This has the same name as the type, and accepts three values as arguments. After a few checks for invalid values, the special new() function creates a new object with the passed-in values. Remember we're still inside the type definition—this is an inner constructor.

  function LSD(a,b,c)
    if a < 0 || b < 0 || c < 0
      error("no negative numbers")
    if c > 12 || b > 20
      error("too many pence or shillings")
    new(a, b, c) 

Now we can finish the type definition:


Here's the complete type definition again:

struct LSD
   function LSD(a, b, c)
    if a < 0 || b < 0 
      error("no negative numbers")
    if c > 12 || b > 20
      error("too many pence or shillings")
    new(a, b, c) 

It's now possible to create new objects that store old-fashioned British prices. You create a new object of this type by using its name (which calls the constructor function):

julia>price1 = LSD(5, 10, 6)
LSD(5, 10, 6)

julia>price2 = LSD(1, 6, 8)
LSD(1, 6, 8)

And you can't create bad prices, because of the simple checks added to the constructor function:

julia> price = LSD(1,0,13)
ERROR: too many pence or shillings
 [1] LSD(::Int64, ::Int64, ::Int64)

If you inspect the fields of one of the price 'objects' we've created:

julia> fieldnames(price1)
3-element Array{Symbol,1}:

you can see the three fields, and these are storing the values:

julia> price1.pounds
julia> price1.shillings
julia> price1.pence

The next task is to make this new type behave in the same way as other Julia objects. For example, we can't add two prices:

julia> price1 + price2
ERROR: MethodError: no method matching +(::LSD, ::LSD)
Closest candidates are:
  +(::Any, ::Any, ::Any, ::Any...) at operators.jl:420

and the output could definitely be improved:

julia> price2
LSD(5, 10, 6)

Julia has the addition function (+) with methods defined for many types of object. The following code adds another method that can handle two LSD objects:

  importall Base.Operators
  function Base.:+(a::LSD, b::LSD)
  newpence = a.pence + b.pence
  newshillings = a.shillings + b.shillings
  newpounds = a.pounds + b.pounds
  subtotal = newpence + newshillings * 12 + newpounds * 240
  (pounds, balance) = divrem(subtotal, 240)
  (shillings, pence) = divrem(balance, 12)
  LSD(pounds, shillings, pence)

This definition teaches Julia how to handle the new LSD objects, and adds a new method to the + function, one that accepts two LSD objects, adds them together, and produces a new LSD object containing the sum.

Now you can add two prices:

julia> price1 + price2

which is indeed the result of adding LSD(5,10,6) and LSD(1,6,8).

The next problem to address is the unattractive presentation of LSD objects. This is fixed in exactly the same way, by adding a new method, but this time to the show() function, which belongs to the Base environment:

function, money::LSD)
    print(io, "£$(money.pounds).$(money.shillings)s.$(money.pence)d")

Here, the io is the output channel currently used by all show() methods. We've added a simple expression that displays the field values with appropriate punctuation and separators.

julia> println(price1 + price2)

julia> show(price1 + price2 + LSD(0,19,11) + LSD(19,19,6))

You can add one or more aliases, which are alternative names for a particular type. Since Price is a better way of saying LSD, we'll create an valid alternative:

julia> const Price LSD

julia> show(Price(1, 19, 11))

So far, so good, but these LSD objects are still not yet fully developed. If you want to do subtraction, multiplication, and division, you have to define additional methods for these functions for handling LSDs. Subtraction is easy enough, just requiring some fiddling with shillings and pence, so we'll leave that for now, but what about multiplication? Multiplying a price by a number involves two types of object, one a Price/LSD object, the other - well, any positive real number should be possible:

import Base.*
function Base.:*(a::LSD, b::Real)
    if b < 0
        error("Cannot multiply by a negative number")

    totalpence = b * (a.pence + a.shillings * 12 + a.pounds * 240)
    (pounds, balance) = divrem(totalpence, 240)
    (shillings, pence) = divrem(balance, 12)
    LSD(pounds, shillings, pence)

Like the + method, this new * method is defined specifically to multiply a price by a number. It works surprisingly well for a first attempt:

julia> price1 * 2
julia> price1 * 3
julia> price1 * 10
julia> price1 * 1.5
julia> price3 = Price(0,6,5)
julia> price3 * 1//7

However, some failures are to be expected,. We didn't allow for the really old-fashioned fractions of a penny: the halfpenny, and the farthing:

julia> price1 * 0.25
ERROR: InexactError()
 [1] convert(::Type{Int64}, ::Float64) at ./float.jl:675
 [2] LSD(::Float64, ::Float64, ::Float64) at ./REPL[36]:40
 [3] *(::LSD, ::Float64) at ./REPL[55]:10

(The answer should be £1.7s.7½d. Unfortunately our LSD type doesn't allow fractions of a penny.)

But there's another, more pressing, problem. At the moment you have to give the price followed by the multiplier; the other way round fails:

julia> 2 * price1
ERROR: MethodError: no method matching *(::Int64, ::LSD)
Closest candidates are:
  *(::Any, ::Any, ::Any, ::Any...) at operators.jl:420
  *(::Number, ::Bool) at bool.jl:106

This is because, although Julia can find a method that matches (a::LSD, b::Number), it can't find it the other way round: (a::Number, b::LSD). But adding it isn't too difficult:

function Base.:*(a::Number, b::LSD)
  b * a

which adds yet another method to the * function.

julia> price1 * 2

julia> 2 * price1 

julia> for i in 1:10
           println(price1 * i)

The prices are now looking like an old British shop from the 19th century, forsooth!

If you want to see how many methods you've added for working with this old British pounds type so far, use the methodswith() function:

julia> methodswith(LSD)
4-element Array{Method,1}:
*(a::LSD, b::Real) at In[20]:4
*(a::Number, b::LSD) at In[34]:2
+(a::LSD, b::LSD) at In[13]:2
show(io::IO, money::LSD) at In[15]:2

Just four so far.... And you can continue to add methods to make the type more generally useful—it would depend on how you envisage yourself or others using it. For example, you probably want to add division and modulo methods, and to act intelligently about negative monetary values.

Importing from Base[edit]

You might see a warning when you add your own custom methods to built-in functions from the Base module, such as + and show():

   ERROR: error in method definition: function ... must be explicitly imported to be extended

To prevent this, you can either use importall Base.Operators before you add methods, or if you're just extending one method, define it using the Base. syntax:

function Base.:*(a::Number, b::LSD)
  b * a

See the chapter on Modules and Packages for more about importing functions from other modules.