Guru delle valutazioni

Finora il programma non ha detto molto sui tipi, ma chiaramente in Julia esistono:

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

Non abbiamo mai specificato i tipi, ma Julia li ha assegnati comunque.

1. Julia ha i types, che sono centrali per la sua progettazione.
2. Julia di solito riesce a «indovinare» il tipo, usando la Type Inference.

Il compilatore JIT esaminerà (tutto) il codice, vedrà come viene usata una variabile e inferirà un tipo predefinito adatto e compatibile con quell'uso.

Assegnazione dei tipi

Affidarsi all'inferenza dei tipi va bene per risolvere semplici esercizi tutorial, ma per programmi più grandi probabilmente ti servirà un controllo più preciso.

Sulla maggior parte dei processori moderni, un intero ha come tipo predefinito Int64. Abbiamo visto nel concetto Numbers che un valore può essere convertito in un tipo specifico non predefinito.

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

Tuttavia, alla variabile x si può ancora assegnare un tipo diverso:

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

Questa è la type instability, ovvero:

• Molto comoda negli script piccoli.
• Dannosa per le prestazioni e l'affidabilità nei programmi più grandi.

Invece, possiamo impostare il tipo di x usando l'operatore :::

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.

Ora y è, e sarà sempre, di tipo Int16. Quindi il compilatore sa quanti byte riservargli e può ottimizzare il resto del codice facendo affidamento su un tipo stabile. In questo, la variabile è più o meno simile a quelle di un linguaggio a tipizzazione statica come C.

La gerarchia dei tipi

Int64, Int16, String, Char: da dove «vengono» questi tipi?

In molti linguaggi orientati agli oggetti (OO), ogni tipo è una classe, la creazione di sottoclassi li organizza in una gerarchia di classi e i metodi delle classi definiscono i comportamenti.

Java e Ruby sono esempi evidenti di questo schema, ma anche Python è simile al suo interno.

Julia non ha classi.

La ragione documentata è che le funzionalità OO interferiscono con il compilatore JIT e danneggiano le prestazioni in fase di esecuzione.

Eppure, guarda questo codice:

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

Aggiungiamo qualche dettaglio:

• Int16 è un tipo e possiamo creare variabili di questo tipo.
• Int16 è un sottotipo di Signed e la funzione supertype() ce lo mostra.
• Esiste una gerarchia di tipi, che risale attraverso Integer, Real e Number fino ad Any in cima, e subtypes() elencherà per noi questo ramo della gerarchia.

Tutti i rami terminano in Any, che ha la particolarità di essere il proprio supertipo.

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

Quindi Julia non ha una gerarchia di class, ma ha una gerarchia di type.

Prima o poi proveremo a districare come funziona, ma prima c'è molto altro da esplorare.

Verificare i tipi

Possiamo usare typeof() per verificare l'uguaglianza nel solito modo.

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

L'uguaglianza tra tipi deve essere esatta, perché questa forma di confronto non comprende la gerarchia dei tipi.

In modo più flessibile, isa ci dirà se un valore ha lo stesso tipo di un comparatore oppure un suo sottotipo. Può essere usato sia in forma di funzione sia in forma infissa.

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

Nota che isa richiede un value a sinistra, non un type.

Provare a confrontare due tipi in questo modo darà risultati inaspettati. L'operatore corretto è <:, che vedremo molto di più nei prossimi concetti.

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

Tipi astratti e tipi concreti

Abbiamo visto che la gerarchia dei tipi forma una struttura ad albero (nel senso dell'informatica, con la radice in cima).

Ogni elemento dell'albero è un node, e questi possono essere divisi in categorie:

1. I nodi con sottotipi sono chiamati abstract.
2. I nodi foglia, senza sottotipi, sono chiamati concrete.

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

Questa è una distinzione importante, perché solo i tipi concreti possono essere instantiated come variabili.

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

Nota che provare a usare un tipo astratto non dà alcun messaggio di errore (in questo caso), ma il compilatore crea un tipo concreto appropriato: Int64 invece di Integer.