Μέχρι τώρα, το syllabus δεν έχει πει πολλά για τους τύπους, αλλά είναι σαφές ότι υπάρχουν στη Julia:
julia> vals = (42, 4.3, π, "hello", 'Q')
(42, 4.3, π, "hello", 'Q')
julia> typeof(vals)
Tuple{Int64, Float64, Irrational{:π}, String, Char}
Δεν προσδιορίσαμε ποτέ τους τύπους, αλλά η Julia τους ανέθεσε ούτως ή άλλως.
- Η Julia έχει
types, οι οποίοι είναι κεντρικοί στον σχεδιασμό της.
- Η Julia συνήθως μπορεί να "μαντέψει" τον τύπο, χρησιμοποιώντας
Type Inference.
Ο μεταγλωττιστής JIT θα κοιτάξει μέσα σε (όλο) τον κώδικα, θα δει πώς χρησιμοποιείται μια μεταβλητή, και θα συμπεράνει έναν κατάλληλο προεπιλεγμένο τύπο συμβατό με αυτή τη χρήση.
Ανάθεση τύπου
Το να βασίζεσαι στην εξαγωγή τύπων είναι εντάξει για την επίλυση απλών ασκήσεων εκμάθησης, αλλά για μεγαλύτερα προγράμματα πιθανότατα θα χρειαστείς πιο ακριβή έλεγχο.
Στους περισσότερους σύγχρονους επεξεργαστές, ένας ακέραιος έχει από προεπιλογή τον τύπο Int64.
Είδαμε στην Έννοια Numbers ότι μια τιμή μπορεί να μετατραπεί σε έναν συγκεκριμένο μη προεπιλεγμένο τύπο.
julia> x = Int16(42)
42
julia> typeof(x)
Int16
Ωστόσο, η μεταβλητή x μπορεί ακόμα να εκχωρηθεί ξανά σε διαφορετικό τύπο:
julia> x = "changed"
"changed"
julia> typeof(x)
String
Αυτό είναι type instability, το οποίο είναι:
- Πολύ βολικό σε μικρά σενάρια.
- Κακό για την απόδοση και την αξιοπιστία σε μεγαλύτερα προγράμματα.
Αντ' αυτού, μπορούμε να ορίσουμε τον τύπο του x χρησιμοποιώντας τον τελεστή :::
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.
Τώρα το y είναι, και θα είναι πάντα, τύπου Int16.
Έτσι, ο μεταγλωττιστής ξέρει πόσα byte να δεσμεύσει για αυτό, και μπορεί να βελτιστοποιήσει τον υπόλοιπο κώδικα ώστε να βασίζεται σε έναν σταθερό τύπο.
Ως προς αυτό, η μεταβλητή είναι λίγο-πολύ παρόμοια με εκείνες σε μια στατικά τυποποιημένη γλώσσα όπως η C.
Η ιεραρχία των τύπων
Int64, Int16, String, Char: από πού "προέρχονται" αυτοί οι τύποι;
Σε πολλές αντικειμενοστρεφείς (OO) γλώσσες, κάθε τύπος είναι μια κλάση, η δημιουργία υποκλάσεων τα τακτοποιεί σε μια ιεραρχία κλάσεων, και οι μέθοδοι κλάσης ορίζουν τις συμπεριφορές.
Η Java και η Ruby είναι προφανή παραδείγματα αυτού του μοτίβου, αλλά ακόμα και η Python είναι παρόμοια εσωτερικά.
Η Julia δεν έχει κλάσεις.
Ο τεκμηριωμένος λόγος είναι ότι τα χαρακτηριστικά του αντικειμενοστρεφούς προγραμματισμού παρεμβαίνουν στον μεταγλωττιστή JIT και βλάπτουν την απόδοση κατά την εκτέλεση.
Κι όμως, κοίτα αυτόν τον κώδικα:
julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> supertype(Int16)
Signed
julia> supertypes(Int16)
(Int16, Signed, Integer, Real, Number, Any)
Συμπληρώνοντας κάποιες λεπτομέρειες:
- Το
Int16 είναι ένας τύπος, και μπορούμε να δημιουργήσουμε μεταβλητές αυτού του τύπου.
- Το
Int16 είναι υπότυπος του Signed, και η συνάρτηση supertype() μας το δείχνει.
- Υπάρχει μια ιεραρχία τύπων, που ανεβαίνει μέσω των
Integer, Real και Number μέχρι το Any στην κορυφή, και η subtypes() θα μας απαριθμήσει αυτόν τον κλάδο της ιεραρχίας.
Όλοι οι κλάδοι καταλήγουν στο Any, το οποίο έχει τη μοναδικότητα να είναι ο ίδιος ο υπέρτυπός του.
julia> supertypes(String)
(String, AbstractString, Any)
julia> supertype(Any)
Any
Έτσι, η Julia δεν έχει ιεραρχία class, αλλά έχει ιεραρχία type.
Κάποια στιγμή θα προσπαθήσουμε να ξεμπερδέψουμε πώς λειτουργεί αυτό, αλλά υπάρχουν πολλά ακόμα να εξερευνήσουμε πρώτα.
Έλεγχος τύπων
Μπορούμε να χρησιμοποιήσουμε τη typeof() για να ελέγξουμε την ισότητα με τον συνηθισμένο τρόπο.
julia> typeof(11)
Int64
julia> typeof(11) == Int64
true
julia> typeof(11) == Number
false
Η ισότητα τύπων πρέπει να είναι ακριβής, καθώς αυτή η μορφή σύγκρισης δεν έχει καμία αντίληψη της ιεραρχίας τύπων.
Πιο ευέλικτα, η isa θα μας πει αν μια τιμή έχει είτε τον ίδιο τύπο με το μέρος σύγκρισης, είτε κάποιον υπότυπό του.
Μπορεί να χρησιμοποιηθεί είτε σε μορφή συνάρτησης είτε σε μορφή ένθετου τελεστή.
julia> 12 isa Int64
true
julia> 12 isa Number
true
julia> isa(12, Number)
true
julia> 12 isa String
false
Σημείωσε ότι η isa περιμένει ένα value στα αριστερά, όχι ένα type.
Το να προσπαθήσεις να συγκρίνεις δύο τύπους με αυτόν τον τρόπο θα δώσει απροσδόκητα αποτελέσματα.
Ο σωστός τελεστής είναι το <:, το οποίο θα δούμε πολύ περισσότερο σε μελλοντικές έννοιες.
julia> Int64 isa Number ## Don't do this!
false
julia> Int64 <: Number
true
Αφηρημένοι έναντι συγκεκριμένων τύπων
Είδαμε ότι η ιεραρχία τύπων σχηματίζει μια δενδρική δομή (με την έννοια της επιστήμης των υπολογιστών, με τη ρίζα στην κορυφή).
Κάθε στοιχείο του δέντρου είναι ένα node, και αυτά μπορούν να χωριστούν σε κατηγορίες:
- Οι κόμβοι που έχουν υποτύπους ονομάζονται
abstract.
- Οι κόμβοι-φύλλα, που δεν έχουν υποτύπους, ονομάζονται
concrete.
julia> subtypes(Integer) # an abstract type
3-element Vector{Any}:
Bool
Signed
Unsigned
julia> subtypes(Int64) # a concrete type
Type[]
Αυτή είναι μια σημαντική διάκριση, γιατί μόνο οι συγκεκριμένοι τύποι μπορούν να γίνουν instantiated ως μεταβλητές.
julia> a::Int16 = 42
42
julia> typeof(a)
Int16
julia> b::Integer = 42
42
julia> typeof(b)
Int64
Σημείωσε ότι το να προσπαθήσεις να χρησιμοποιήσεις έναν αφηρημένο τύπο δεν εμφανίζει κανένα μήνυμα σφάλματος (σε αυτή την περίπτωση), αλλά ο μεταγλωττιστής δημιουργεί έναν κατάλληλο συγκεκριμένο τύπο: Int64 αντί για Integer.
Άσκηση εκμάθησης
