Guru das notas

Até agora, o syllabus não disse muito sobre tipos, mas é claro que eles existem em Julia:

julia> vals = (42, 4.3, π, "hello", 'Q')
(42, 4.3, π, "hello", 'Q')
julia> typeof(vals)
Tuple{Int64, Float64, Irrational{:π}, String, Char}

Nunca especificamos os tipos, mas Julia os atribuiu de qualquer forma.

1. Julia tem types, que são centrais no design da linguagem.
2. Julia geralmente consegue "adivinhar" o tipo, usando Type Inference.

O compilador JIT vai percorrer (todo) o código, ver como uma variável é usada e inferir um tipo padrão adequado, compatível com esse uso.

Atribuição de tipos

Contar com a inferência de tipos dá conta de exercícios simples de tutorial, mas, em programas maiores, você provavelmente vai precisar de um controle mais preciso.

Na maioria dos processadores modernos, um inteiro tem Int64 como tipo padrão. Vimos no Conceito Numbers que um valor pode ser convertido para um tipo específico diferente do padrão.

julia> x = Int16(42)
42
julia> typeof(x)
Int16

No entanto, a variável x ainda pode ser reatribuída a um tipo diferente:

julia> x = "changed"
"changed"
julia> typeof(x)
String

Isso é type instability, que é:

• Muito conveniente em scripts pequenos.
• Ruim para o desempenho e a confiabilidade em programas maiores.

Em vez disso, podemos definir o tipo de x usando o operador :::

julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> y = "changed"
ERROR: MethodError: Cannot `convert` an object of type String to an object of type Int16
The function `convert` exists, but no method is defined for this combination of argument types.

Agora y é do tipo Int16, e sempre será. Assim, o compilador sabe quantos bytes reservar para ela e pode otimizar o restante do código contando com um tipo estável. Nesse aspecto, a variável é mais ou menos parecida com as de uma linguagem de tipagem estática, como C.

A hierarquia de tipos

Int64, Int16, String, Char: de onde "vêm" esses tipos?

Em muitas linguagens orientadas a objetos (OO), cada tipo é uma classe, a criação de subclasses as organiza em uma hierarquia de classes, e os métodos de classe definem os comportamentos.

Java e Ruby são exemplos óbvios desse padrão, mas até o Python é parecido internamente.

Julia não tem classes.

O motivo documentado é que os recursos de orientação a objetos interferem no compilador JIT e prejudicam o desempenho em tempo de execução.

E, mesmo assim, veja este código:

julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> supertype(Int16)
Signed
julia> supertypes(Int16)
(Int16, Signed, Integer, Real, Number, Any)

Detalhando um pouco:

• Int16 é um tipo, e podemos criar variáveis desse tipo.
• Int16 é um subtipo de Signed, e a função supertype() nos mostra isso.
• Há uma hierarquia de tipos, que sobe por Integer, Real e Number até Any, no topo, e subtypes() vai listar esse ramo da hierarquia para nós.

Todos os ramos terminam em Any, que é único por ser seu próprio supertipo.

julia> supertypes(String)
(String, AbstractString, Any)
julia> supertype(Any)
Any

Então, Julia não tem uma hierarquia de class, mas tem uma hierarquia de type.

Mais adiante, vamos tentar destrinchar como isso funciona, mas há muito mais para explorar antes.

Testando tipos

Podemos usar typeof() para testar igualdade da maneira habitual.

julia> typeof(11)
Int64
julia> typeof(11) == Int64
true
julia> typeof(11) == Number
false

A igualdade de tipos precisa ser exata, pois essa forma de comparação não entende nada da hierarquia de tipos.

De forma mais flexível, isa nos diz se um valor tem o mesmo tipo do que está sendo comparado ou um subtipo dele. Ele pode ser usado tanto na forma de função quanto na forma infixa.

julia> 12 isa Int64
true
julia> 12 isa Number
true
julia> isa(12, Number)
true
julia> 12 isa String
false

Repare que isa espera um value à esquerda, não um type.

Tentar comparar dois tipos dessa forma vai dar resultados inesperados. O operador correto é <:, que vamos ver muito mais em conceitos futuros.

julia> Int64 isa Number  ## Don't do this!
false
julia> Int64 <: Number
true

Tipos abstratos versus concretos

Vimos que a hierarquia de tipos forma uma estrutura de árvore (no sentido da Ciência da Computação, com a raiz no topo).

Cada item da árvore é um node, e eles podem ser divididos em categorias:

1. Nós com subtipos são chamados de abstract.
2. Nós folha, sem subtipos, são chamados de concrete.

julia> subtypes(Integer)  # an abstract type
3-element Vector{Any}:
 Bool
 Signed
 Unsigned
julia> subtypes(Int64)  # a concrete type
Type[]

Essa é uma distinção importante, porque só tipos concretos podem ser instantiated como variáveis.

julia> a::Int16 = 42
42
julia> typeof(a)
Int16
julia> b::Integer = 42
42
julia> typeof(b)
Int64

Repare que tentar usar um tipo abstrato não gera mensagem de erro (neste caso), mas o compilador cria um tipo concreto adequado: Int64 em vez de Integer.