Grammaire de type

Quand:

• vous spécifiez des restrictions de type
• vous spécifiez des arguments de type
• vous déclarez des variables
• vous déclarez des aliases
• vous déclarez des typedefs
• pour l'argument d'un pseudo-appel à is_a?
• pour l'argument d'une expression as
• pour l'argument d'une expression sizeof
• pour l'argument d'un expression instance_sizeof
• pour le type de retour d'une méthode

Une syntaxe pratique est fournie pour certains types communs. Elles sont surtout utiles lors de l'écriture de liaisons C, mais peuvent être utilisées depuis n'importe lequel des emplacements précédents.

Chemins et génériques:

Les génériques et types usuels peuvent être utilisés:

Int32
My::Nested::Type
Array(String)

Union

alias Int32OrString = Int32 | String

Le tube (|) dans les types crée un type union. Int32 | String se lit "Int32 ou String". Dans du code usuel, Int32 | String signifie invoquer la méthode | sur Int32 avec String comme argument.

Nilable

alias Int32OrNil = Int32?

Est équivalent à:

alias Int32OrNil = Int32 | ::Nil

Dans du code usuel, Int32? est une erreur de syntaxe.

Pointeur

alias Int32Ptr = Int32*

Est équivalent à:

alias Int32Ptr = Pointer(Int32)

Dans du code usuel, Int32* signifie invoquer la méthode * sur Int32.

StaticArray

alias Int32_8 = Int32[8]

Est équivalent à:

alias Int32_8 = StaticArray(Int32, 8)

Dans du code usuel, Int32[8] signifie invoquer la méthode [] sur Int32 avec 8 comme argument.

Tuple

alias Int32StringTuple = {Int32, String}

Est équivalent à:

alias Int32StringTuple = Tuple(Int32, String)

Dans du code usuel, {Int32, String} est une instance de tuple contenant Int32 et String comme éléments. C'est différent du type tuple précédent.

NamedTuple

alias Int32StringNamedTuple = {x: Int32, y: String}

Est équivalent à:

alias Int32StringNamedTuple = NamedTuple(x: Int32, y: String)

Dans du code usuel, {x: Int32, y: String} est une instance de tuple nommé contenant Int32 et String pour x et y. C'est différent du type de tuple nommé précédent.

Proc

alias Int32ToString = Int32 -> String

Est équivalent à:

alias Int32ToString = Proc(Int32, String)

Pour spécifier un Proc sans argument:

alias ProcThatReturnsInt32 = -> Int32

Pour spécifier plusieurs arguments:

alias Int32AndCharToString = Int32, Char -> String

Pour des procs imbriqués (et pour tout type en général), vous pouvez utiliser des parenthèses:

alias ComplexProc = (Int32 -> Int32) -> String

Dans du code usuel Int32 -> String est une erreur de syntaxe.

self

self peut être utilisé dans la grammaire de type pour dénoter un type self. Reportez-vous à la section sur les restrictions de type.

class

class est utilisée pour se référer à un type de classe, au lieu d'un type d'instance.

Par exemple:

def foo(x : Int32)
  "instance"
end

def foo(x : Int32.class)
  "class"
end

foo 1     # "instance"
foo Int32 # "class"

class est aussi utile pour créer des arrays et collections de type de classe:

class Parent
end

class Child1 < Parent
end

class Child2 < Parent
end

ary = [] of Parent.class
ary << Child1
ary << Child2

Underscore

Un souligné (tiret bas) est permis dans les restrictions de type. Il effectue une correspondance avec n'importe quoi:

# équivalent à spécifier une restriction, pas très utile
def foo(x : _)
end

# Un petit peu plus utile: deux Procs arguments qui retournent un Int32:
def foo(x : _, _ -> Int32)
end

typeof

typeof est permis dans la grammaire de type. Il retourne un type d'union du type des expressions passées:

alias SameAsInt32 = typeof(1 + 2)
alias Int32OrString = typeof(1, "a")