Tipos en Julia | conjunto 2

Prerrequisito: Tipos en Julia | Serie 1

Los tipos en Julia son grupos de elementos de datos que se utilizan para hacer que la ejecución del programa sea más rápida y más factible de leer. Los tipos ayudan a encontrar errores y aportan claridad al código fuente. Julia utiliza Dynamic Typed System para escribir valores de variables, pero también acepta definiciones de tipo estático para proporcionar la ventaja de indicar que ciertos valores son de tipos específicos. De forma predeterminada, Julia asigna los valores sin tipo con cualquier tipo requerido.

Tipos declarados

Hay tres tipos de tipos, como se explica en el Conjunto 1 de este artículo. Estos son:

• Tipos abstractos
• tipos primitivos
• Tipos compuestos

Estos tres tipos de tipos están estrechamente relacionados entre sí. Las propiedades de estos tipos son casi similares:

• Todos ellos están declarados explícitamente.
• Siempre se definen con sus nombres.
• Los supertipos de los tres tipos se declaran explícitamente
• Pueden contener algunos parámetros.

Todos estos tipos son instancias de un solo tipo llamado DataType debido a las propiedades mencionadas anteriormente que comparten. Un DataType puede ser de tipo abstracto o concreto dependiendo de las propiedades. Cada valor concreto es una instancia de algún tipo de datos. Si es primitivo, entonces tiene un tamaño distinto de cero sin un nombre de campo especificado y para el tipo de datos compuesto debe contener el nombre del campo y puede estar vacío.
Ejemplo:

Tipo Unión

La asignación de más de un tipo como instancia a un valor se realiza con el uso de la palabra clave ‘ Union‘ . Una unión de tipos es un tipo especial que incluye todas las instancias de cualquier tipo de argumento como objetos.
Los compiladores de otros lenguajes tienen su propia construcción de unión pero internamente, que se usa para decidir sobre el tipo de valor, pero Julia permite a los programadores crear su propio conjunto de tipos de argumentos de unión. Esto ayuda a Julia a generar códigos eficientes con mayor velocidad de ejecución porque, con la ayuda de Union, tiene que saber verificar entre una pequeña cantidad de tipos, declarados por el programador.

Ejemplo:

# Declaring Union of types
StringorFloat = Union{AbstractString, AbstractFloat}
  
# Function with argument of Union type
function Geeks(x::StringorFloat)
    println(x)
end
  
# Function call
Geeks("Hello")
Geeks(10.5)
Geeks(10)

En el código anterior, cuando la función se pasa con un argumento de tipo Int, el compilador genera un error porque el argumento de la función es una unión de los tipos Float y String pero no Integer.

Julia permite pasar parámetros a sus tipos, lo que da como resultado la generación de un rango completamente nuevo de tipos, uno para cada combinación de valor de parámetro.
Todos los tipos declarados llamados DataType en general, pueden ser parametrizados. Esta declaración de tipo parametrizado sigue la misma sintaxis para cada una de las posibilidades.
Hay tres tipos de tipos paramétricos:

• Tipos compuestos paramétricos
• Tipos abstractos paramétricos
• Tipos primitivos paramétricos

Tipos compuestos paramétricos

En un tipo compuesto paramétrico, los parámetros se escriben inmediatamente después del nombre del tipo encerrado entre llaves. El parámetro aquí es de tipo general {T}, donde T puede ser cualquier tipo.
Sintaxis:

struct {T}
    Field_name1::T
    Field_name2::T
end

Arriba se da una sintaxis general para tipos compuestos paramétricos. Aquí, T se puede reemplazar con cualquier tipo concreto como Int64, Float64, AbstractString, etc. Cada uno de estos se convertirá en un tipo concreto utilizable.

El nombre de la estructura también se puede utilizar como un objeto de tipo válido, es decir, cada uno de los tipos creados anteriormente debe ser un subtipo del tipo ‘Geeks’.

Todos los demás tipos que no se declaran en Tipos parametrizados no son un subtipo.

Ejemplo:

# Type declaration for
# Parametric Composite Type
struct Geeks{T}
    x::T
    y::T
end
  
# Checking for Types
Geeks("Hello", "Geeks")
Geeks(10, 20)

Tipos abstractos paramétricos

Los tipos abstractos paramétricos se declaran de forma similar a como se declararon los tipos abstractos. En un tipo abstracto paramétrico, se utiliza el tipo abstracto de prefijo , los parámetros se escriben inmediatamente después del nombre del tipo encerrado entre llaves. El parámetro aquí es de tipo general {T}, donde T puede ser cualquier tipo.
Sintaxis:

abstract type {T} end

Arriba se muestra una sintaxis general para los tipos abstractos paramétricos. Aquí, T se puede reemplazar con cualquier tipo concreto como Int64, Float64, AbstractString, etc.

Como en los tipos compuestos, cada tipo paramétrico será un subtipo del tipo ‘Geeks’.

Estos subtipos son todos diferentes entre sí y no son un subtipo uno del otro:

Si creamos otra declaración de Tipo y luego la definimos como un subtipo de la declaración de Tipo actual, entonces las instancias del nuevo tipo serán un subtipo del Tipo existente:

Tipos primitivos paramétricos

Al igual que los tipos compuestos y abstractos, los tipos primitivos también se pueden declarar paramétricamente. En un tipo primitivo paramétrico, se usa el tipo primitivo de prefijo , los parámetros se escriben inmediatamente después del nombre del tipo encerrado entre llaves. El parámetro aquí es de tipo general {T}, donde T puede ser cualquier tipo.
Sintaxis:

# For 32 bit
primitive type {T} 32 end

# For 64 bit
primitive type {T} 64 end

Arriba se muestra una sintaxis general para los tipos abstractos paramétricos. Aquí, T se puede reemplazar con cualquier tipo concreto como Int64, Float64, AbstractString, etc.

Los tipos primitivos paramétricos funcionan de manera similar a los tipos compuestos y abstractos.

Métodos de tipo