Essentials

exit(code=0)

Detiene el programa con un código de salida. El código de salida predeterminado es cero, lo que indica que el programa se completó con éxito. En una sesión interactiva, exit() se puede llamar con el atajo de teclado ^D.

atexit(f)

Registra una función de cero o un argumento f() que se llamará al salir del proceso. Los ganchos de atexit() se llaman en orden de último en entrar, primero en salir (LIFO) y se ejecutan antes de los finalizadores de objetos.

Si f tiene un método definido para un argumento entero, se llamará como f(n::Int32), donde n es el código de salida actual; de lo contrario, se llamará como f().

Se permite que los ganchos de salida llamen a exit(n), en cuyo caso Julia saldrá con el código de salida n (en lugar del código de salida original). Si más de un gancho de salida llama a exit(n), entonces Julia saldrá con el código de salida correspondiente al último gancho de salida llamado que llama a exit(n). (Debido a que los ganchos de salida se llaman en orden LIFO, "último llamado" es equivalente a "primero registrado".)

Nota: Una vez que se han llamado todos los ganchos de salida, no se pueden registrar más ganchos de salida, y cualquier llamada a atexit(f) después de que todos los ganchos se hayan completado lanzará una excepción. Esta situación puede ocurrir si estás registrando ganchos de salida desde Tareas en segundo plano que aún pueden estar ejecutándose de manera concurrente durante el apagado.

isinteractive() -> Bool

Determina si Julia está ejecutándose en una sesión interactiva.

Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int

Calcula la cantidad de memoria, en bytes, utilizada por todos los objetos únicos accesibles desde el argumento.

Argumentos Clave

• exclude: especifica los tipos de objetos a excluir de la travesía.
• chargeall: especifica los tipos de objetos a los que siempre se les cobrará el tamaño de todos sus campos, incluso si esos campos normalmente serían excluidos.

Véase también sizeof.

Ejemplos

julia> Base.summarysize(1.0)
8

julia> Base.summarysize(Ref(rand(100)))
848

julia> sizeof(Ref(rand(100)))
8

__precompile__(isprecompilable::Bool)

Especifica si el archivo que llama a esta función es precompilable, con un valor predeterminado de true. Si un módulo o archivo no es seguro para la precompilación, debe llamar a __precompile__(false) para lanzar un error si Julia intenta precompilarlo.

Base.include([mapexpr::Function,] m::Module, path::AbstractString)

Evalúa el contenido del archivo de origen de entrada en el ámbito global del módulo m. Cada módulo (excepto aquellos definidos con baremodule) tiene su propia definición de include omitiendo el argumento m, que evalúa el archivo en ese módulo. Devuelve el resultado de la última expresión evaluada del archivo de entrada. Durante la inclusión, se establece una ruta de inclusión local a la tarea en el directorio que contiene el archivo. Las llamadas anidadas a include buscarán en relación con esa ruta. Esta función se utiliza típicamente para cargar código fuente de forma interactiva, o para combinar archivos en paquetes que están divididos en múltiples archivos de origen.

El primer argumento opcional mapexpr se puede usar para transformar el código incluido antes de que se evalúe: para cada expresión analizada expr en path, la función include en realidad evalúa mapexpr(expr). Si se omite, mapexpr por defecto es identity.

include([mapexpr::Function,] path::AbstractString)

Evalúa el contenido del archivo de origen de entrada en el ámbito global del módulo que lo contiene. Cada módulo (excepto aquellos definidos con baremodule) tiene su propia definición de include, que evalúa el archivo en ese módulo. Devuelve el resultado de la última expresión evaluada del archivo de entrada. Durante la inclusión, se establece una ruta de inclusión local a la tarea en el directorio que contiene el archivo. Las llamadas anidadas a include buscarán en relación con esa ruta. Esta función se utiliza típicamente para cargar código fuente de forma interactiva, o para combinar archivos en paquetes que están divididos en múltiples archivos de origen. El argumento path se normaliza utilizando normpath que resolverá los tokens de ruta relativa como .. y convertirá / en el separador de ruta apropiado.

El primer argumento opcional mapexpr se puede usar para transformar el código incluido antes de que se evalúe: para cada expresión analizada expr en path, la función include en realidad evalúa mapexpr(expr). Si se omite, mapexpr por defecto es identity.

Usa Base.include para evaluar un archivo en otro módulo.

include_string([mapexpr::Function,] m::Module, code::AbstractString, filename::AbstractString="string")

Como include, excepto que lee el código de la cadena dada en lugar de un archivo.

El primer argumento opcional mapexpr se puede usar para transformar el código incluido antes de que se evalúe: para cada expresión analizada expr en code, la función include_string evalúa en realidad mapexpr(expr). Si se omite, mapexpr por defecto es identity.

include_dependency(path::AbstractString; track_content::Bool=true)

En un módulo, declara que el archivo, directorio o enlace simbólico especificado por path (relativo o absoluto) es una dependencia para la precompilación; es decir, si track_content=true, el módulo necesitará ser recompilado si el contenido de path cambia (si path es un directorio, el contenido es igual a join(readdir(path))). Si track_content=false, la recompilación se activa cuando el tiempo de modificación mtime de path cambia.

Esto solo es necesario si tu módulo depende de una ruta que no se utiliza a través de include. No tiene efecto fuera de la compilación.

__init__

La función __init__() en un módulo se ejecuta inmediatamente después de que el módulo se carga en tiempo de ejecución por primera vez. Se llama una vez, después de que todas las demás declaraciones en el módulo han sido ejecutadas. Debido a que se llama después de importar completamente el módulo, las funciones __init__ de los submódulos se ejecutarán primero. Dos usos típicos de __init__ son llamar a funciones de inicialización en tiempo de ejecución de bibliotecas externas en C e inicializar constantes globales que involucran punteros devueltos por bibliotecas externas. Consulta la sección del manual sobre módulos para más detalles.

Ejemplos

const foo_data_ptr = Ref{Ptr{Cvoid}}(0)
function __init__()
    ccall((:foo_init, :libfoo), Cvoid, ())
    foo_data_ptr[] = ccall((:foo_data, :libfoo), Ptr{Cvoid}, ())
    nothing
end

which(f, types)

Devuelve el método de f (un objeto Method) que se llamaría para argumentos de los tipos dados types.

Si types es un tipo abstracto, se devuelve el método que sería llamado por invoke.

Véase también: parentmodule, @which, y @edit.

methods(f, [types], [module])

Devuelve la tabla de métodos para f.

Si se especifica types, devuelve un array de métodos cuyas tipos coinciden. Si se especifica module, devuelve un array de métodos definidos en ese módulo. También se puede especificar una lista de módulos como un array.

Véase también: which, @which y methodswith.

@show exs...

Imprime una o más expresiones, y sus resultados, en stdout, y devuelve el último resultado.

Véase también: show, @info, println.

Ejemplos

julia> x = @show 1+2
1 + 2 = 3
3

julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5

ans

Una variable que se refiere al último valor calculado, importada automáticamente al prompt interactivo.

err

Una variable que se refiere a los últimos errores lanzados, importada automáticamente al prompt interactivo. Los errores lanzados se recopilan en una pila de excepciones.

active_project()

Devuelve la ruta del archivo Project.toml activo. Ver también Base.set_active_project.

set_active_project(projfile::Union{AbstractString,Nothing})

Establece el archivo Project.toml activo a projfile. Ver también Base.active_project.

módulo

módulo declara un Módulo, que es un espacio de trabajo de variables globales separado. Dentro de un módulo, puedes controlar qué nombres de otros módulos son visibles (a través de la importación) y especificar cuáles de tus nombres están destinados a ser públicos (a través de export y public). Los módulos te permiten crear definiciones de nivel superior sin preocuparte por conflictos de nombres cuando tu código se utiliza junto con el de otra persona. Consulta la sección del manual sobre módulos para más detalles.

Ejemplos

módulo Foo
importar Base.show
exportar MyType, foo

estructura MyType
    x
end

bar(x) = 2x
foo(a::MyType) = bar(a.x) + 1
show(io::IO, a::MyType) = print(io, "MyType $(a.x)")
end

export

export se utiliza dentro de los módulos para indicar a Julia qué nombres deben estar disponibles para el usuario. Por ejemplo: export foo hace que el nombre foo esté disponible al usar el módulo. Consulta la sección del manual sobre módulos para más detalles.

public

public se utiliza dentro de los módulos para indicar a Julia qué nombres son parte de la API pública del módulo. Por ejemplo: public foo indica que el nombre foo es público, sin hacerlo disponible al using el módulo. Consulta la sección del manual sobre módulos para más detalles.

import

import Foo cargará el módulo o paquete Foo. Los nombres del módulo Foo importado se pueden acceder con la sintaxis de punto (por ejemplo, Foo.foo para acceder al nombre foo). Consulta la sección del manual sobre módulos para más detalles.

using

using Foo cargará el módulo o paquete Foo y hará que sus nombres exportados estén disponibles para su uso directo. Los nombres también se pueden usar a través de la sintaxis de punto (por ejemplo, Foo.foo para acceder al nombre foo), ya sea que estén exportados o no. Consulta la sección del manual sobre módulos para más detalles.

as

as se utiliza como una palabra clave para renombrar un identificador traído al ámbito por import o using, con el propósito de evitar conflictos de nombres así como para acortar nombres. (Fuera de las declaraciones import o using, as no es una palabra clave y puede ser utilizado como un identificador ordinario.)

import LinearAlgebra as LA trae la biblioteca estándar LinearAlgebra importada al ámbito como LA.

import LinearAlgebra: eigen as eig, cholesky as chol trae los métodos eigen y cholesky de LinearAlgebra al ámbito como eig y chol respectivamente.

as funciona con using solo cuando se traen identificadores individuales al ámbito. Por ejemplo, using LinearAlgebra: eigen as eig o using LinearAlgebra: eigen as eig, cholesky as chol funciona, pero using LinearAlgebra as LA es una sintaxis inválida, ya que no tiene sentido renombrar todos los nombres exportados de LinearAlgebra a LA.

baremodule

baremodule declara un módulo que no contiene using Base ni definiciones locales de eval y include. Sin embargo, todavía importa Core. En otras palabras,

module Mod

...

end

es equivalente a

baremodule Mod

using Base

eval(x) = Core.eval(Mod, x)
include(p) = Base.include(Mod, p)

...

end

function

Las funciones se definen con la palabra clave function:

function add(a, b)
    return a + b
end

O la notación en forma corta:

add(a, b) = a + b

El uso de la palabra clave return es exactamente el mismo que en otros lenguajes, pero a menudo es opcional. Una función sin una declaración return explícita devolverá la última expresión en el cuerpo de la función.

macro

macro define un método para insertar código generado en un programa. Un macro mapea una secuencia de expresiones de argumento a una expresión devuelta, y la expresión resultante se sustituye directamente en el programa en el punto donde se invoca el macro. Los macros son una forma de ejecutar código generado sin llamar a eval, ya que el código generado simplemente se convierte en parte del programa circundante. Los argumentos de los macros pueden incluir expresiones, valores literales y símbolos. Los macros se pueden definir para un número variable de argumentos (varargs), pero no aceptan argumentos de palabra clave. Cada macro también recibe implícitamente los argumentos __source__, que contiene el número de línea y el nombre del archivo desde el cual se llama al macro, y __module__, que es el módulo en el que se expande el macro.

Consulta la sección del manual sobre Metaprogramación para obtener más información sobre cómo escribir un macro.

Ejemplos

julia> macro sayhello(name)
           return :( println("Hello, ", $name, "!") )
       end
@sayhello (macro with 1 method)

julia> @sayhello "Charlie"
Hello, Charlie!

julia> macro saylots(x...)
           return :( println("Say: ", $(x...)) )
       end
@saylots (macro with 1 method)

julia> @saylots "hey " "there " "friend"
Say: hey there friend

return

return x hace que la función que lo contiene salga anticipadamente, pasando el valor dado x de vuelta a su llamador. return por sí solo sin un valor es equivalente a return nothing (ver nothing).

function compare(a, b)
    a == b && return "equal to"
    a < b ? "less than" : "greater than"
end

En general, puedes colocar una declaración return en cualquier lugar dentro del cuerpo de una función, incluyendo dentro de bucles o condicionales profundamente anidados, pero ten cuidado con los bloques do. Por ejemplo:

function test1(xs)
    for x in xs
        iseven(x) && return 2x
    end
end

function test2(xs)
    map(xs) do x
        iseven(x) && return 2x
        x
    end
end

En el primer ejemplo, el return sale de test1 tan pronto como encuentra un número par, por lo que test1([5,6,7]) devuelve 12.

Podrías esperar que el segundo ejemplo se comportara de la misma manera, pero de hecho el return allí solo sale de la función interna (dentro del bloque do) y devuelve un valor a map. test2([5,6,7]) entonces devuelve [5,12,7].

Cuando se usa en una expresión de nivel superior (es decir, fuera de cualquier función), return hace que toda la expresión de nivel superior actual termine anticipadamente.

do

Crea una función anónima y pásala como el primer argumento a una llamada de función. Por ejemplo:

map(1:10) do x
    2x
end

es equivalente a map(x->2x, 1:10).

Usa múltiples argumentos de la siguiente manera:

map(1:10, 11:20) do x, y
    x + y
end

begin

begin...end denota un bloque de código.

begin
    println("Hola, ")
    println("¡Mundo!")
end

Usualmente begin no será necesario, ya que palabras clave como function y let comienzan implícitamente bloques de código. Ver también ;.

begin también puede ser utilizado al indexar para representar el primer índice de una colección o el primer índice de una dimensión de un arreglo. Por ejemplo, a[begin] es el primer elemento de un arreglo a.

Ejemplos

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> A[begin, :]
2-element Array{Int64,1}:
 1
 2

end

end marca la conclusión de un bloque de expresiones, por ejemplo module, struct, mutable struct, begin, let, for etc.

end también puede ser utilizado al indexar para representar el último índice de una colección o el último índice de una dimensión de un arreglo.

Ejemplos

julia> A = [1 2; 3 4]
2×2 Array{Int64, 2}:
 1  2
 3  4

julia> A[end, :]
2-element Array{Int64, 1}:
 3
 4

let

Los bloques let crean un nuevo ámbito rígido y, opcionalmente, introducen nuevos enlaces locales.

Al igual que los otros constructos de ámbito, los bloques let definen el bloque de código donde las variables locales recién introducidas son accesibles. Además, la sintaxis tiene un significado especial para las asignaciones separadas por comas y los nombres de variables que pueden aparecer opcionalmente en la misma línea que el let:

let var1 = value1, var2, var3 = value3
    code
end

Las variables introducidas en esta línea son locales al bloque let y las asignaciones se evalúan en orden, con cada lado derecho evaluado en el ámbito sin considerar el nombre en el lado izquierdo. Por lo tanto, tiene sentido escribir algo como let x = x, ya que las dos variables x son distintas, con el lado izquierdo ocultando localmente el x del ámbito exterior. Esto puede ser incluso un modismo útil, ya que se crean nuevas variables locales cada vez que se ingresan ámbitos locales, pero esto solo es observable en el caso de variables que sobreviven a su ámbito a través de cierres. Una variable let sin una asignación, como var2 en el ejemplo anterior, declara una nueva variable local que aún no está vinculada a un valor.

Por el contrario, los bloques begin también agrupan múltiples expresiones, pero no introducen un ámbito ni tienen la sintaxis de asignación especial.

Ejemplos

En la función a continuación, hay un solo x que se actualiza iterativamente tres veces por el map. Los cierres devueltos hacen referencia a ese único x en su valor final:

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generic function with 1 method)

julia> [f() for f in test_outer_x()]
3-element Vector{Int64}:
 3
 3
 3

Sin embargo, si agregamos un bloque let que introduce una nueva variable local, terminaremos con tres variables distintas siendo capturadas (una en cada iteración) a pesar de que elegimos usar (ocultar) el mismo nombre.

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generic function with 1 method)

julia> [f() for f in test_let_x()]
3-element Vector{Int64}:
 1
 2
 3

Todos los constructos de ámbito que introducen nuevas variables locales se comportan de esta manera cuando se ejecutan repetidamente; la característica distintiva de let es su capacidad para declarar de manera sucinta nuevos locals que pueden ocultar variables externas del mismo nombre. Por ejemplo, usar directamente el argumento de la función do captura de manera similar tres variables distintas:

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generic function with 1 method)

julia> [f() for f in test_do_x()]
3-element Vector{Int64}:
 1
 2
 3

if/elseif/else

if/elseif/else realiza una evaluación condicional, lo que permite que partes del código se evalúen o no se evalúen dependiendo del valor de una expresión booleana. Aquí está la anatomía de la sintaxis condicional if/elseif/else:

if x < y
    println("x es menor que y")
elseif x > y
    println("x es mayor que y")
else
    println("x es igual a y")
end

Si la expresión de condición x < y es verdadera, entonces el bloque correspondiente se evalúa; de lo contrario, se evalúa la expresión de condición x > y, y si es verdadera, se evalúa el bloque correspondiente; si ninguna de las expresiones es verdadera, se evalúa el bloque else. Los bloques elseif y else son opcionales, y se pueden usar tantos bloques elseif como se desee.

A diferencia de algunos otros lenguajes, las condiciones deben ser de tipo Bool. No es suficiente que las condiciones sean convertibles a Bool.

julia> if 1 end
ERROR: TypeError: non-boolean (Int64) used in boolean context

for

Los bucles for evalúan repetidamente un bloque de declaraciones mientras iteran sobre una secuencia de valores.

La variable de iteración siempre es una nueva variable, incluso si existe una variable con el mismo nombre en el ámbito que la rodea. Usa outer para reutilizar una variable local existente para la iteración.

Ejemplos

julia> for i in [1, 4, 0]
           println(i)
       end
1
4
0

mientras

mientras los bucles evalúan repetidamente una expresión condicional y continúan evaluando el cuerpo del bucle mientras la expresión siga siendo verdadera. Si la expresión de condición es falsa cuando se alcanza por primera vez el bucle mientras, el cuerpo nunca se evalúa.

Ejemplos

julia> i = 1
1

julia> mientras i < 5
           println(i)
           global i += 1
       end
1
2
3
4

break

Salga de un bucle inmediatamente.

Ejemplos

julia> i = 0
0

julia> while true
           global i += 1
           i > 5 && break
           println(i)
       end
1
2
3
4
5

continue

Saltar la iteración actual del bucle.

Ejemplos

julia> for i = 1:6
           iseven(i) && continue
           println(i)
       end
1
3
5

try/catch

Una declaración try/catch permite interceptar errores (excepciones) lanzados por throw para que la ejecución del programa pueda continuar. Por ejemplo, el siguiente código intenta escribir un archivo, pero advierte al usuario y procede en lugar de terminar la ejecución si el archivo no se puede escribir:

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "No se pudo escribir el archivo."
end

o, cuando el archivo no se puede leer en una variable:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "Archivo no encontrado."
end

La sintaxis catch e (donde e es cualquier variable) asigna el objeto de excepción lanzado a la variable dada dentro del bloque catch.

El poder de la construcción try/catch radica en la capacidad de deshacer una computación profundamente anidada inmediatamente a un nivel mucho más alto en la pila de funciones llamadas.

finalmente

Ejecuta algún código cuando un bloque de código dado sale, independientemente de cómo salga. Por ejemplo, aquí se muestra cómo podemos garantizar que un archivo abierto se cierre:

f = open("file")
try
    operate_on_file(f)
finally
    close(f)
end

Cuando el control sale del bloque try (por ejemplo, debido a un return, o simplemente finalizando normalmente), close(f) se ejecutará. Si el bloque try sale debido a una excepción, la excepción continuará propagándose. Un bloque catch puede combinarse con try y finally también. En este caso, el bloque finally se ejecutará después de que catch haya manejado el error.

quote

quote crea múltiples objetos de expresión en un bloque sin usar el constructor explícito Expr. Por ejemplo:

ex = quote
    x = 1
    y = 2
    x + y
end

A diferencia de otros medios de citar, :( ... ), esta forma introduce elementos QuoteNode en el árbol de expresiones, que deben ser considerados al manipular directamente el árbol. Para otros propósitos, :( ... ) y los bloques quote .. end se tratan de manera idéntica.

local

local introduce una nueva variable local. Consulta la sección del manual sobre el alcance de las variables para más información.

Ejemplos

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # introduce un x local al bucle
               x = i
           end
           x
       end
foo (función genérica con 1 método)

julia> foo(10)
0

global

global x hace que x en el ámbito actual y sus ámbitos internos se refiera a la variable global de ese nombre. Consulta la sección del manual sobre el alcance de las variables para más información.

Ejemplos

julia> z = 3
3

julia> function foo()
           global z = 6 # usa la variable z definida fuera de foo
       end
foo (función genérica con 1 método)

julia> foo()
6

julia> z
6

for outer

Reutiliza una variable local existente para la iteración en un bucle for.

Consulta la sección del manual sobre el alcance de las variables para más información.

Consulta también for.

Ejemplos

julia> function f()
           i = 0
           for i = 1:3
               # vacío
           end
           return i
       end;

julia> f()
0

julia> function f()
           i = 0
           for outer i = 1:3
               # vacío
           end
           return i
       end;

julia> f()
3

julia> i = 0 # variable global
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]

const

const se utiliza para declarar variables globales cuyos valores no cambiarán. En casi todo el código (y particularmente en el código sensible al rendimiento), las variables globales deben declararse constantes de esta manera.

const x = 5

Se pueden declarar múltiples variables dentro de un solo const:

const y, z = 7, 11

Ten en cuenta que const solo se aplica a una operación de =; por lo tanto, const x = y = 1 declara x como constante pero no y. Por otro lado, const x = const y = 1 declara tanto x como y constantes.

Ten en cuenta que la "constancia" no se extiende a contenedores mutables; solo la asociación entre una variable y su valor es constante. Si x es un arreglo o un diccionario (por ejemplo), aún puedes modificar, agregar o eliminar elementos.

En algunos casos, cambiar el valor de una variable const da una advertencia en lugar de un error. Sin embargo, esto puede producir un comportamiento impredecible o corromper el estado de tu programa, por lo que debe evitarse. Esta característica está destinada solo para conveniencia durante el uso interactivo.

struct

El tipo más comúnmente utilizado en Julia es un struct, especificado como un nombre y un conjunto de campos.

struct Point
    x
    y
end

Los campos pueden tener restricciones de tipo, que pueden ser parametrizadas:

struct Point{X}
    x::X
    y::Float64
end

Un struct también puede declarar un supertipo abstracto a través de la sintaxis <::

struct Point <: AbstractPoint
    x
    y
end

Los structs son inmutables por defecto; una instancia de uno de estos tipos no puede ser modificada después de su construcción. Usa mutable struct en su lugar para declarar un tipo cuyas instancias pueden ser modificadas.

Consulta la sección del manual sobre Tipos Compuestos para más detalles, como cómo definir constructores.

mutable struct

mutable struct es similar a struct, pero además permite que los campos del tipo se establezcan después de la construcción.

Los campos individuales de un mutable struct pueden ser marcados como const para hacerlos inmutables:

mutable struct Baz
    a::Int
    const b::Float64
end

Consulta la sección del manual sobre Composite Types para más información.

@kwdef typedef

Este es un macro auxiliar que define automáticamente un constructor basado en palabras clave para el tipo declarado en la expresión typedef, que debe ser una expresión de struct o mutable struct. El argumento predeterminado se proporciona declarando campos de la forma field::T = default o field = default. Si no se proporciona un valor predeterminado, entonces el argumento de palabra clave se convierte en un argumento de palabra clave requerido en el constructor de tipo resultante.

Los constructores internos aún se pueden definir, pero al menos uno debe aceptar argumentos en la misma forma que el constructor interno predeterminado (es decir, un argumento posicional por campo) para funcionar correctamente con el constructor externo de palabras clave.

Ejemplos

julia> @kwdef struct Foo
           a::Int = 1         # valor predeterminado especificado
           b::String          # palabra clave requerida
       end
Foo

julia> Foo(b="hi")
Foo(1, "hi")

julia> Foo()
ERROR: UndefKeywordError: argumento de palabra clave `b` no asignado
Stacktrace:
[...]

tipo abstracto

tipo abstracto declara un tipo que no puede ser instanciado, y sirve solo como un nodo en el gráfico de tipos, describiendo así conjuntos de tipos concretos relacionados: aquellos tipos concretos que son sus descendientes. Los tipos abstractos forman la jerarquía conceptual que hace que el sistema de tipos de Julia sea más que solo una colección de implementaciones de objetos. Por ejemplo:

abstract type Number end
abstract type Real <: Number end

Number no tiene supertipo, mientras que Real es un subtipo abstracto de Number.

tipo primitivo

tipo primitivo declara un tipo concreto cuyos datos consisten únicamente en una serie de bits. Ejemplos clásicos de tipos primitivos son los enteros y los valores de punto flotante. Algunas declaraciones de tipos primitivos incorporados como ejemplo:

tipo primitivo Char 32 fin
tipo primitivo Bool <: Integer 8 fin

El número después del nombre indica cuántos bits de almacenamiento requiere el tipo. Actualmente, solo se admiten tamaños que son múltiplos de 8 bits. La declaración Bool muestra cómo un tipo primitivo puede declararse opcionalmente como un subtipo de algún supertipo.

donde

La palabra clave where crea un tipo UnionAll, que puede considerarse como una unión iterada de otros tipos, sobre todos los valores de alguna variable. Por ejemplo, Vector{T} where T<:Real incluye todos los Vectors donde el tipo de elemento es algún tipo de número Real.

El límite de la variable se establece de forma predeterminada en Any si se omite:

Vector{T} where T    # abreviatura de `where T<:Any`

Las variables también pueden tener límites inferiores:

Vector{T} where T>:Int
Vector{T} where Int<:T<:Real

También hay una sintaxis concisa para expresiones where anidadas. Por ejemplo, esto:

Pair{T, S} where S<:Array{T} where T<:Number

se puede acortar a:

Pair{T, S} where {T<:Number, S<:Array{T}}

Esta forma se encuentra a menudo en las firmas de métodos.

Ten en cuenta que en esta forma, las variables se enumeran de afuera hacia adentro. Esto coincide con el orden en el que se sustituyen las variables cuando un tipo se "aplica" a valores de parámetros utilizando la sintaxis T{p1, p2, ...}.

El operador "splat", `...`, representa una secuencia de argumentos. `...` se puede usar en definiciones de funciones, para indicar que la función acepta un número arbitrario de argumentos. `...` también se puede usar para aplicar una función a una secuencia de argumentos.

# Ejemplos

jldoctest julia> add(xs...) = reduce(+, xs) add (generic function with 1 method)

julia> add(1, 2, 3, 4, 5) 15

julia> add([1, 2, 3]...) 6

julia> add(7, 1:100..., 1000:1100...) 111107

;

; tiene un papel similar en Julia que en muchos lenguajes similares a C, y se utiliza para delimitar el final de la declaración anterior.

; no es necesario al final de una línea, pero se puede usar para separar declaraciones en una sola línea o para unir declaraciones en una sola expresión.

Agregar ; al final de una línea en el REPL suprimirá la impresión del resultado de esa expresión.

En las declaraciones de funciones, y opcionalmente en las llamadas, ; separa los argumentos regulares de las palabras clave.

En literales de arreglos, los argumentos separados por punto y coma tienen su contenido concatenado. Un separador hecho de un solo ; concatena verticalmente (es decir, a lo largo de la primera dimensión), ;; concatena horizontalmente (segunda dimensión), ;;; concatena a lo largo de la tercera dimensión, etc. Tal separador también se puede usar en la última posición en los corchetes cuadrados para agregar dimensiones adicionales de longitud 1.

Un ; en la primera posición dentro de paréntesis se puede usar para construir una tupla nombrada. La misma sintaxis (; ...) en el lado izquierdo de una asignación permite la desestructuración de propiedades.

En el REPL estándar, escribir ; en una línea vacía cambiará al modo shell.

Ejemplos

julia> function foo()
           x = "Hello, "; x *= "World!"
           return x
       end
foo (generic function with 1 method)

julia> bar() = (x = "Hello, Mars!"; return x)
bar (generic function with 1 method)

julia> foo();

julia> bar()
"Hello, Mars!"

julia> function plot(x, y; style="solid", width=1, color="black")
           ###
       end

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> [1; 3;; 2; 4;;; 10*A]
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 10  20
 30  40

julia> [2; 3;;;]
2×1×1 Array{Int64, 3}:
[:, :, 1] =
 2
 3

julia> nt = (; x=1) # sin el ; o una coma final esto asignaría a x
(x = 1,)

julia> key = :a; c = 3;

julia> nt2 = (; key => 1, b=2, c, nt.x)
(a = 1, b = 2, c = 3, x = 1)

julia> (; b, x) = nt2; # establecer variables b y x usando desestructuración de propiedades

julia> b, x
(2, 1)

julia> ; # al escribir ;, el aviso cambia (en su lugar) a: shell>
shell> echo hello
hello

=

= es el operador de asignación.

• Para la variable a y la expresión b, a = b hace que a se refiera al valor de b.
• Para funciones f(x), f(x) = x define una nueva constante de función f, o agrega un nuevo método a f si f ya está definido; este uso es equivalente a function f(x); x; end.
• a[i] = v llama a setindex!(a,v,i).
• a.b = c llama a setproperty!(a,:b,c).
• Dentro de una llamada a función, f(a=b) pasa b como el valor del argumento de palabra clave a.
• Dentro de paréntesis con comas, (a=1,) construye un NamedTuple.

Ejemplos

Asignar a a b no crea una copia de b; en su lugar, usa copy o deepcopy.

julia> b = [1]; a = b; b[1] = 2; a
1-element Array{Int64, 1}:
 2

julia> b = [1]; a = copy(b); b[1] = 2; a
1-element Array{Int64, 1}:
 1

Las colecciones pasadas a funciones tampoco se copian. Las funciones pueden modificar (mutar) el contenido de los objetos a los que se refieren sus argumentos. (Los nombres de las funciones que hacen esto se les añade convencionalmente un sufijo '!'.)

julia> function f!(x); x[:] .+= 1; end
f! (generic function with 1 method)

julia> a = [1]; f!(a); a
1-element Array{Int64, 1}:
 2

La asignación puede operar en múltiples variables en paralelo, tomando valores de un iterable:

julia> a, b = 4, 5
(4, 5)

julia> a, b = 1:3
1:3

julia> a, b
(1, 2)

La asignación puede operar en múltiples variables en serie, y devolverá el valor de la expresión más a la derecha:

julia> a = [1]; b = [2]; c = [3]; a = b = c
1-element Array{Int64, 1}:
 3

julia> b[1] = 2; a, b, c
([2], [2], [2])

La asignación en índices fuera de límites no hace crecer una colección. Si la colección es un Vector se puede hacer crecer en su lugar con push! o append!.

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: attempt to access 2-element Array{Int64, 1} at index [3]
[...]

julia> push!(a, 2, 3)
4-element Array{Int64, 1}:
 1
 1
 2
 3

Asignar [] no elimina elementos de una colección; en su lugar, usa filter!.

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch: tried to assign 0 elements to 1 destinations
[...]

julia> filter!(x -> x > 1, a) # in-place & thus more efficient than a = a[a .> 1]
2-element Array{Int64, 1}:
 2
 3

a ? b : c

Forma corta para condicionales; se lee "si a, evalúa b de lo contrario evalúa c". También conocido como el operador ternario.

Esta sintaxis es equivalente a if a; b else c end, pero a menudo se utiliza para enfatizar el valor b-o-c que se está utilizando como parte de una expresión más grande, en lugar de los efectos secundarios que la evaluación de b o c puede tener.

Consulta la sección del manual sobre flujo de control para más detalles.

Ejemplos

julia> x = 1; y = 2;

julia> x > y ? println("x es mayor") : println("x no es mayor")
x no es mayor

julia> x > y ? "x es mayor" : x == y ? "x e y son iguales" : "y es mayor"
"y es mayor"

Main

Main es el módulo de nivel superior, y Julia comienza con Main establecido como el módulo actual. Las variables definidas en el aviso van en Main, y varinfo lista las variables en Main.

julia> @__MODULE__
Main

Núcleo

Núcleo es el módulo que contiene todos los identificadores considerados "incorporados" al lenguaje, es decir, parte del lenguaje básico y no de bibliotecas. Cada módulo especifica implícitamente using Núcleo, ya que no puedes hacer nada sin esas definiciones.

Base

La biblioteca base de Julia. Base es un módulo que contiene funcionalidad básica (el contenido de base/). Todos los módulos contienen implícitamente using Base, ya que esto es necesario en la gran mayoría de los casos.

Base.Broadcast

Módulo que contiene la implementación de la difusión.

Docs

El módulo Docs proporciona el macro @doc que se puede utilizar para establecer y recuperar metadatos de documentación para objetos de Julia.

Por favor, consulte la sección del manual sobre documentación para más información.

Métodos para trabajar con Iteradores.

Interfaz a libc, la biblioteca estándar de C.

Funciones de conveniencia para metaprogramación.

Herramientas para recopilar y manipular trazas de pila. Principalmente utilizadas para construir errores.

Proporcione métodos para recuperar información sobre el hardware y el sistema operativo.

Soporte de multihilo.

Base.GC

Módulo con utilidades de recolección de basura.

===(x,y) -> Bool
≡(x,y) -> Bool

Determina si x e y son idénticos, en el sentido de que ningún programa podría distinguirlos. Primero se comparan los tipos de x e y. Si son idénticos, los objetos mutables se comparan por dirección en memoria y los objetos inmutables (como los números) se comparan por contenido a nivel de bits. Esta función a veces se llama "egal". Siempre devuelve un valor Bool.

Ejemplos

julia> a = [1, 2]; b = [1, 2];

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

Determina si x es del tipo dado type. También se puede usar como un operador infijo, por ejemplo, x isa type.

Ejemplos

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

isequal(x, y) -> Bool

Similar a ==, excepto por el tratamiento de números de punto flotante y de valores faltantes. isequal trata todos los valores NaN de punto flotante como iguales entre sí, trata -0.0 como desigual a 0.0, y missing como igual a missing. Siempre devuelve un valor Bool.

isequal es una relación de equivalencia: es reflexiva (=== implica isequal), simétrica (isequal(a, b) implica isequal(b, a)) y transitiva (isequal(a, b) y isequal(b, c) implica isequal(a, c)).

Implementación

La implementación predeterminada de isequal llama a ==, por lo que un tipo que no involucra valores de punto flotante generalmente solo necesita definir ==.

isequal es la función de comparación utilizada por tablas hash (Dict). isequal(x,y) debe implicar que hash(x) == hash(y).

Esto significa que los tipos para los cuales existe un método personalizado == o isequal deben implementar un método correspondiente hash (y viceversa). Las colecciones generalmente implementan isequal llamando a isequal recursivamente en todos los contenidos.

Además, isequal está vinculado con isless, y trabajan juntos para definir un orden total fijo, donde exactamente uno de isequal(x, y), isless(x, y), o isless(y, x) debe ser true (y los otros dos false).

Los tipos escalares generalmente no necesitan implementar isequal por separado de ==, a menos que representen números de punto flotante que sean susceptibles a una implementación más eficiente que la proporcionada como una alternativa genérica (basada en isnan, signbit, y ==).

Ejemplos

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

julia> missing == missing
missing

julia> isequal(missing, missing)
true

isequal(x)

Crea una función que compara su argumento con x utilizando isequal, es decir, una función equivalente a y -> isequal(y, x).

La función devuelta es de tipo Base.Fix2{typeof(isequal)}, que se puede utilizar para implementar métodos especializados.

isless(x, y)

Prueba si x es menor que y, de acuerdo con un orden total fijo (definido junto con isequal). isless no está definido para pares (x, y) de todos los tipos. Sin embargo, si está definido, se espera que satisfaga lo siguiente:

• Si isless(x, y) está definido, entonces también lo están isless(y, x) y isequal(x, y), y exactamente uno de esos tres devuelve true.
• La relación definida por isless es transitiva, es decir, isless(x, y) && isless(y, z) implica isless(x, z).

Los valores que normalmente no tienen orden, como NaN, se ordenan después de los valores regulares. Los valores missing se ordenan al final.

Esta es la comparación predeterminada utilizada por sort!.

Implementación

Los tipos no numéricos con un orden total deben implementar esta función. Los tipos numéricos solo necesitan implementarla si tienen valores especiales como NaN. Los tipos con un orden parcial deben implementar <. Consulta la documentación sobre Ordenamientos Alternativos para saber cómo definir métodos de ordenamiento alternativos que se pueden utilizar en funciones de ordenamiento y relacionadas.

Ejemplos

julia> isless(1, 3)
true

julia> isless("Red", "Blue")
false

isunordered(x)

Devuelve true si x es un valor que no se puede ordenar de acuerdo con <, como NaN o missing.

Los valores que evalúan a true con este predicado pueden ser ordenables con respecto a otros ordenamientos como isless.

ifelse(condition::Bool, x, y)

Devuelve x si condition es true, de lo contrario devuelve y. Esto difiere de ? o if en que es una función ordinaria, por lo que todos los argumentos se evalúan primero. En algunos casos, usar ifelse en lugar de una declaración if puede eliminar la rama en el código generado y proporcionar un mayor rendimiento en bucles ajustados.

Ejemplos

julia> ifelse(1 > 2, 1, 2)
2

typeassert(x, type)

Lanza un TypeError a menos que x isa type. La sintaxis x::type llama a esta función.

Ejemplos

julia> typeassert(2.5, Int)
ERROR: TypeError: in typeassert, expected Int64, got a value of type Float64
Stacktrace:
[...]

typeof(x)

Obtén el tipo concreto de x.

Consulta también eltype.

Ejemplos

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

julia> M = [1 2; 3.5 4];

julia> typeof(M)
Matrix{Float64} (alias for Array{Float64, 2})

tuple(xs...)

Construye una tupla de los objetos dados.

Véase también Tuple, ntuple, NamedTuple.

Ejemplos

julia> tuple(1, 'b', pi)
(1, 'b', π)

julia> ans === (1, 'b', π)
true

julia> Tuple(Real[1, 2, pi])  # toma una colección
(1, 2, π)

ntuple(f, n::Integer)

Crea una tupla de longitud n, computando cada elemento como f(i), donde i es el índice del elemento.

Ejemplos

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)

ntuple(f, ::Val{N})

Crea una tupla de longitud N, calculando cada elemento como f(i), donde i es el índice del elemento. Al tomar un argumento Val(N), es posible que esta versión de ntuple genere un código más eficiente que la versión que toma la longitud como un entero. Pero ntuple(f, N) es preferible a ntuple(f, Val(N)) en casos donde N no se puede determinar en tiempo de compilación.

Ejemplos

julia> ntuple(i -> 2*i, Val(4))
(2, 4, 6, 8)

objectid(x) -> UInt

Obtiene un valor hash para x basado en la identidad del objeto.

Si x === y entonces objectid(x) == objectid(y), y generalmente cuando x !== y, objectid(x) != objectid(y).

Ver también hash, IdDict.

hash(x[, h::UInt]) -> UInt

Calcula un código hash entero tal que isequal(x,y) implica hash(x)==hash(y). El segundo argumento opcional h es otro código hash que se mezcla con el resultado.

Los nuevos tipos deben implementar la forma de 2 argumentos, típicamente llamando al método hash de 2 argumentos de forma recursiva para mezclar los hashes de los contenidos entre sí (y con h). Típicamente, cualquier tipo que implemente hash también debería implementar su propio == (de ahí isequal) para garantizar la propiedad mencionada anteriormente.

El valor hash puede cambiar cuando se inicia un nuevo proceso de Julia.

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # solo usa la salida de otra función hash como segundo argumento
0xd42bad54a8575b16

Ver también: objectid, Dict, Set.

finalizer(f, x)

Registra una función f(x) que se llamará cuando no haya referencias accesibles al programa para x, y devuelve x. El tipo de x debe ser un mutable struct, de lo contrario, la función lanzará una excepción.

f no debe causar un cambio de tarea, lo que excluye la mayoría de las operaciones de E/S como println. Usar el macro @async (para diferir el cambio de contexto fuera del finalizador) o ccall para invocar directamente funciones de E/S en C puede ser útil para fines de depuración.

Ten en cuenta que no hay una edad de mundo garantizada para la ejecución de f. Puede ser llamada en la edad de mundo en la que se registró el finalizador o en cualquier edad de mundo posterior.

Ejemplos

finalizer(my_mutable_struct) do x
    @async println("Finalizando $x.")
end

finalizer(my_mutable_struct) do x
    ccall(:jl_safe_printf, Cvoid, (Cstring, Cstring), "Finalizando %s.", repr(x))
end

Un finalizador puede ser registrado en la construcción del objeto. En el siguiente ejemplo, ten en cuenta que confiamos implícitamente en que el finalizador devuelve el mutable struct recién creado x.

mutable struct MyMutableStruct
    bar
    function MyMutableStruct(bar)
        x = new(bar)
        f(t) = @async println("Finalizando $t.")
        finalizer(f, x)
    end
end

finalize(x)

Ejecuta inmediatamente los finalizadores registrados para el objeto x.

copy(x)

Crea una copia superficial de x: se copia la estructura externa, pero no todos los valores internos. Por ejemplo, copiar un arreglo produce un nuevo arreglo con elementos idénticos al original.

Véase también copy!, copyto!, deepcopy.

deepcopy(x)

Crea una copia profunda de x: todo se copia recursivamente, resultando en un objeto completamente independiente. Por ejemplo, hacer una copia profunda de un arreglo crea copias profundas de todos los objetos que contiene y produce un nuevo arreglo con la estructura de relación consistente (por ejemplo, si los dos primeros elementos son el mismo objeto en el arreglo original, los dos primeros elementos del nuevo arreglo también serán el mismo objeto deepcopyed). Llamar a deepcopy en un objeto debería tener generalmente el mismo efecto que serializar y luego deserializarlo.

Aunque normalmente no es necesario, los tipos definidos por el usuario pueden anular el comportamiento predeterminado de deepcopy definiendo una versión especializada de la función deepcopy_internal(x::T, dict::IdDict) (que no debería usarse de otra manera), donde T es el tipo para el que se va a especializar, y dict lleva un registro de los objetos copiados hasta ahora dentro de la recursión. Dentro de la definición, deepcopy_internal debería usarse en lugar de deepcopy, y la variable dict debería actualizarse según sea apropiado antes de devolver.

getproperty(value, name::Symbol)
getproperty(value, name::Symbol, order::Symbol)

La sintaxis a.b llama a getproperty(a, :b). La sintaxis @atomic order a.b llama a getproperty(a, :b, :order) y la sintaxis @atomic a.b llama a getproperty(a, :b, :sequentially_consistent).

Ejemplos

julia> struct MyType{T <: Number}
           x::T
       end

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # fallback to getfield
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

Uno debería sobrecargar getproperty solo cuando sea necesario, ya que puede ser confuso si el comportamiento de la sintaxis obj.f es inusual. También tenga en cuenta que usar métodos es a menudo preferible. Consulte también esta documentación de la guía de estilo para más información: Prefer exported methods over direct field access.

Consulte también getfield, propertynames y setproperty!.

setproperty!(value, name::Symbol, x)
setproperty!(value, name::Symbol, x, order::Symbol)

La sintaxis a.b = c llama a setproperty!(a, :b, c). La sintaxis @atomic order a.b = c llama a setproperty!(a, :b, c, :order) y la sintaxis @atomic a.b = c llama a setproperty!(a, :b, c, :sequentially_consistent).

Véase también setfield!, propertynames y getproperty.

replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

Realiza una operación de comparación e intercambio en x.f de expected a desired, según egal. La sintaxis @atomicreplace x.f expected => desired se puede usar en lugar de la forma de llamada a la función.

Véase también replacefield! setproperty!, setpropertyonce!.

swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)

La sintaxis @atomic a.b, _ = c, a.b devuelve (c, swapproperty!(a, :b, c, :sequentially_consistent)), donde debe haber una expresión getproperty común a ambos lados.

Véase también swapfield! y setproperty!.

modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)

La sintaxis @atomic op(x.f, v) (y su equivalente @atomic x.f op v) devuelve modifyproperty!(x, :f, op, v, :sequentially_consistent), donde el primer argumento debe ser una expresión getproperty y se modifica de manera atómica.

La invocación de op(getproperty(x, f), v) debe devolver un valor que se pueda almacenar en el campo f del objeto x por defecto. En particular, a diferencia del comportamiento predeterminado de setproperty!, la función convert no se llama automáticamente.

Véase también modifyfield! y setproperty!.

setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

Realiza una operación de comparación e intercambio en x.f para establecerlo en value si anteriormente no estaba establecido. La sintaxis @atomiconce x.f = value se puede usar en lugar de la forma de llamada a la función.

Véase también setfieldonce!, setproperty!, replaceproperty!.

propertynames(x, private=false)

Obtiene una tupla o un vector de las propiedades (x.property) de un objeto x. Esto es típicamente lo mismo que fieldnames(typeof(x)), pero los tipos que sobrecargan getproperty generalmente deberían sobrecargar propertynames también para obtener las propiedades de una instancia del tipo.

propertynames(x) puede devolver solo los nombres de propiedades "públicas" que son parte de la interfaz documentada de x. Si deseas que también devuelva los nombres de propiedades "privadas" destinadas para uso interno, pasa true como segundo argumento opcional. La finalización de tabulación en el REPL sobre x. muestra solo las propiedades private=false.

Consulta también: hasproperty, hasfield.

hasproperty(x, s::Symbol)

Devuelve un booleano que indica si el objeto x tiene s como una de sus propias propiedades.

Véase también: propertynames, hasfield.

getfield(value, name::Symbol, [order::Symbol])
getfield(value, i::Int, [order::Symbol])

Extrae un campo de un value compuesto por nombre o posición. Opcionalmente, se puede definir un orden para la operación. Si el campo fue declarado @atomic, se recomienda encarecidamente que la especificación sea compatible con los almacenes en esa ubicación. De lo contrario, si no se declara como @atomic, este parámetro debe ser :not_atomic si se especifica. Ver también getproperty y fieldnames.

Ejemplos

julia> a = 1//2
1//2

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])

Asigna x a un campo nombrado en value de tipo compuesto. El value debe ser mutable y x debe ser un subtipo de fieldtype(typeof(value), name). Además, se puede especificar un orden para esta operación. Si el campo fue declarado @atomic, esta especificación es obligatoria. De lo contrario, si no se declara como @atomic, debe ser :not_atomic si se especifica. Véase también setproperty!.

Ejemplos

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

julia> setfield!(a, :field, 2);

julia> getfield(a, :field)
2

julia> a = 1//2
1//2

julia> setfield!(a, :num, 3);
ERROR: setfield!: immutable struct of type Rational cannot be changed

modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair

Realiza de manera atómica las operaciones para obtener y establecer un campo después de aplicar la función op.

y = getfield(value, name)
z = op(y, x)
setfield!(value, name, z)
return y => z

Si es compatible con el hardware (por ejemplo, incremento atómico), esto puede optimizarse a la instrucción de hardware apropiada; de lo contrario, utilizará un bucle.

replacefield!(value, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
replacefield!(value, i::Int, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

Realiza atómicamente las operaciones para obtener y condicionalmente establecer un campo a un valor dado.

y = getfield(value, name, fail_order)
ok = y === expected
if ok
    setfield!(value, name, desired, success_order)
end
return (; old = y, success = ok)

Si es compatible con el hardware, esto puede optimizarse a la instrucción de hardware apropiada; de lo contrario, utilizará un bucle.

swapfield!(value, name::Symbol, x, [order::Symbol])
swapfield!(value, i::Int, x, [order::Symbol])

Realiza atómicamente las operaciones para obtener y establecer simultáneamente un campo:

y = getfield(value, name)
setfield!(value, name, x)
return y

setfieldonce!(value, name::Union{Int,Symbol}, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

Realiza atómicamente las operaciones para establecer un campo a un valor dado, solo si no se había establecido previamente.

ok = !isdefined(value, name, fail_order)
if ok
    setfield!(value, name, desired, success_order)
end
return ok

isdefined(m::Module, s::Symbol, [order::Symbol])
isdefined(object, s::Symbol, [order::Symbol])
isdefined(object, index::Int, [order::Symbol])

Prueba si una variable global o un campo de objeto está definido. Los argumentos pueden ser un módulo y un símbolo o un objeto compuesto y el nombre del campo (como un símbolo) o índice. Opcionalmente, se puede definir un orden para la operación. Si el campo fue declarado @atomic, se recomienda encarecidamente que la especificación sea compatible con las asignaciones a esa ubicación. De lo contrario, si no se declara como @atomic, este parámetro debe ser :not_atomic si se especifica.

Para probar si un elemento de un arreglo está definido, utiliza isassigned en su lugar.

Ver también @isdefined.

Ejemplos

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false

@isdefined s -> Bool

Prueba si la variable s está definida en el ámbito actual.

Consulta también isdefined para propiedades de campo y isassigned para índices de matriz o haskey para otros mapeos.

Ejemplos

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

julia> function f()
           println(@isdefined x)
           x = 3
           println(@isdefined x)
       end
f (generic function with 1 method)

julia> f()
false
true

convert(T, x)

Convierte x a un valor del tipo T.

Si T es un tipo de Integer, se generará un InexactError si x no es representable por T, por ejemplo, si x no es un valor entero, o está fuera del rango soportado por T.

Ejemplos

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError: Int64(3.5)
Stacktrace:
[...]

Si T es un tipo de AbstractFloat, entonces devolverá el valor más cercano a x representable por T. Inf se trata como una ulp mayor que floatmax(T) para fines de determinación del más cercano.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

Si T es un tipo de colección y x es una colección, el resultado de convert(T, x) puede hacer referencia a todo o parte de x.

julia> x = Int[1, 2, 3];

julia> y = convert(Vector{Int}, x);

julia> y === x
true

Ver también: round, trunc, oftype, reinterpret.

promote(xs...)

Convierte todos los argumentos a un tipo común y los devuelve todos (como una tupla). Si no se pueden convertir argumentos, se genera un error.

Véase también: promote_type, promote_rule.

Ejemplos

julia> promote(Int8(1), Float16(4.5), Float32(4.1))
(1.0f0, 4.5f0, 4.1f0)

julia> promote_type(Int8, Float16, Float32)
Float32

julia> reduce(Base.promote_typejoin, (Int8, Float16, Float32))
Real

julia> promote(1, "x")
ERROR: la promoción de tipos Int64 y String no pudo cambiar ningún argumento
[...]

julia> promote_type(Int, String)
Any

oftype(x, y)

Convierte y al tipo de x, es decir, convert(typeof(x), y).

Ejemplos

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

Si x es un tipo, devuelve un tipo "más grande", definido de tal manera que las operaciones aritméticas + y - están garantizadas de no desbordarse ni perder precisión para cualquier combinación de valores que el tipo x puede contener.

Para tipos de enteros de tamaño fijo menores de 128 bits, widen devolverá un tipo con el doble de bits.

Si x es un valor, se convierte a widen(typeof(x)).

Ejemplos

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

La función identidad. Devuelve su argumento.

Véase también: one, oneunit, y I de LinearAlgebra.

Ejemplos

julia> identity("Well, what did you expect?")
"Well, what did you expect?"

WeakRef(x)

w = WeakRef(x) construye una referencia débil al valor de Julia x: aunque w contiene una referencia a x, no impide que x sea recolectado por el recolector de basura. w.value es x (si x no ha sido recolectado por el recolector de basura aún) o nothing (si x ha sido recolectado por el recolector de basura).

julia> x = "a string"
"a string"

julia> w = WeakRef(x)
WeakRef("a string")

julia> GC.gc()

julia> w           # se mantiene una referencia a través de `x`
WeakRef("a string")

julia> x = nothing # limpiar referencia

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

Devuelve el supertipo del tipo de dato T.

Ejemplos

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type es un tipo abstracto que tiene todos los objetos de tipo como sus instancias. La única instancia del tipo singleton Core.Type{T} es el objeto T.

Ejemplos

julia> isa(Type{Float64}, Type)
true

julia> isa(Float64, Type)
true

julia> isa(Real, Type{Float64})
false

julia> isa(Real, Type{Real})
true

DataType <: Type{T}

DataType representa tipos declarados explícitamente que tienen nombres, supertipos declarados explícitamente y, opcionalmente, parámetros. Cada valor concreto en el sistema es una instancia de algún DataType.

Ejemplos

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

Operador de subtipo: devuelve true si y solo si todos los valores del tipo T1 también son del tipo T2.

Ejemplos

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}
false

>:(T1, T2)

Operador de supertipo, equivalente a T2 <: T1.

typejoin(T, S, ...)

Devuelve el ancestro común más cercano de los tipos T y S, es decir, el tipo más estrecho del cual ambos heredan. Recurre en argumentos adicionales.

Ejemplos

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

typeintersect(T::Type, S::Type)

Calcula un tipo que contiene la intersección de T y S. Normalmente, este será el tipo más pequeño o uno cercano a él.

Un caso especial donde se garantiza un comportamiento exacto: cuando T <: S, typeintersect(S, T) == T == typeintersect(T, S).

promote_type(type1, type2, ...)

La promoción se refiere a convertir valores de tipos mixtos a un único tipo común. promote_type representa el comportamiento de promoción predeterminado en Julia cuando los operadores (generalmente matemáticos) reciben argumentos de tipos diferentes. promote_type generalmente intenta devolver un tipo que al menos pueda aproximar la mayoría de los valores de cualquiera de los tipos de entrada sin ampliar excesivamente. Se tolera cierta pérdida; por ejemplo, promote_type(Int64, Float64) devuelve Float64 aunque estrictamente, no todos los valores de Int64 pueden ser representados exactamente como valores de Float64.

Véase también: promote, promote_typejoin, promote_rule.

Ejemplos

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16

promote_rule(type1, type2)

Especifica qué tipo debe ser utilizado por promote cuando se le dan valores de los tipos type1 y type2. Esta función no debe ser llamada directamente, sino que se deben agregar definiciones a ella para nuevos tipos según sea apropiado.

promote_typejoin(T, S)

Calcula un tipo que contiene tanto T como S, que podría ser un padre de ambos tipos, o un Union si es apropiado. Recurre a typejoin.

Ver también promote, promote_type.

Ejemplos

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

Determina si el tipo T es un "tipo hoja de tupla", lo que significa que podría aparecer como una firma de tipo en la dispatch y no tiene subtipos (o supertipos) que podrían aparecer en una llamada. Si T no es un tipo, entonces devuelve false.

ismutable(v) -> Bool

Devuelve true si y solo si el valor v es mutable. Consulta Tipos Compuestos Mutables para una discusión sobre la inmutabilidad. Ten en cuenta que esta función trabaja con valores, por lo que si le das un DataType, te dirá que un valor del tipo es mutable.

Consulta también isbits, isstructtype.

Ejemplos

julia> ismutable(1)
false

julia> ismutable([1,2])
true

isimmutable(v) -> Bool

Devuelve true si y solo si el valor v es inmutable. Consulta Tipos Compuestos Mutables para una discusión sobre la inmutabilidad. Ten en cuenta que esta función trabaja con valores, por lo que si le das un tipo, te dirá que un valor de DataType es mutable.

Ejemplos

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

Determina si el tipo T fue declarado como un tipo mutable (es decir, utilizando la palabra clave mutable struct). Si T no es un tipo, entonces devuelve false.

isabstracttype(T)

Determina si el tipo T fue declarado como un tipo abstracto (es decir, utilizando la sintaxis abstract type). Ten en cuenta que esto no es la negación de isconcretetype(T). Si T no es un tipo, entonces devuelve false.

Ejemplos

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

Determina si el tipo T fue declarado como un tipo primitivo (es decir, utilizando la sintaxis primitive type). Si T no es un tipo, entonces devuelve false.

Base.issingletontype(T)

Determina si el tipo T tiene exactamente una posible instancia; por ejemplo, un tipo de estructura sin campos excepto otros valores singleton. Si T no es un tipo concreto, entonces devuelve false.

isstructtype(T) -> Bool

Determina si el tipo T fue declarado como un tipo de estructura (es decir, utilizando la palabra clave struct o mutable struct). Si T no es un tipo, entonces devuelve false.

nameof(t::DataType) -> Symbol

Obtiene el nombre de un DataType (potencialmente envuelto en UnionAll) (sin su módulo padre) como un símbolo.

Ejemplos

julia> module Foo
           struct S{T}
           end
       end
Foo

julia> nameof(Foo.S{T} where T)
:S

fieldnames(x::DataType)

Obtiene una tupla con los nombres de los campos de un DataType.

Véase también propertynames, hasfield.

Ejemplos

julia> fieldnames(Rational)
(:num, :den)

julia> fieldnames(typeof(1+im))
(:re, :im)

fieldname(x::DataType, i::Integer)

Obtiene el nombre del campo i de un DataType.

Ejemplos

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

fieldtype(T, name::Symbol | index::Int)

Determina el tipo declarado de un campo (especificado por nombre o índice) en un tipo de dato compuesto T.

Ejemplos

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

Los tipos declarados de todos los campos en un DataType compuesto T como una tupla.

Ejemplos

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

Obtiene el número de campos que tendría una instancia del tipo dado. Se lanza un error si el tipo es demasiado abstracto para determinar esto.

hasfield(T::Type, name::Symbol)

Devuelve un booleano que indica si T tiene name como uno de sus propios campos.

Véase también fieldnames, fieldcount, hasproperty.

Ejemplos

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

nfields(x) -> Int

Obtiene el número de campos en el objeto dado.

Ejemplos

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("He hecho algo malo");

julia> nfields(ex)
1

En estos ejemplos, a es un Rational, que tiene dos campos. b es un Int, que es un tipo de bit primitivo sin campos en absoluto. ex es un ErrorException, que tiene un campo.

isconst(m::Module, s::Symbol) -> Bool

Determina si una variable global está declarada como const en un módulo dado m.

isconst(t::DataType, s::Union{Int,Symbol}) -> Bool

Determina si un campo s está declarado como const en un tipo dado t.

isfieldatomic(t::DataType, s::Union{Int,Symbol}) -> Bool

Determina si un campo s está declarado @atomic en un tipo dado t.

sizeof(T::DataType)
sizeof(obj)

Tamaño, en bytes, de la representación binaria canónica del DataType dado T, si existe. O el tamaño, en bytes, del objeto obj si no es un DataType.

Véase también Base.summarysize.

Ejemplos

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof(collect(1.0:10.0))
80

julia> struct StructWithPadding
           x::Int64
           flag::Bool
       end

julia> sizeof(StructWithPadding) # no es la suma de `sizeof` de los campos debido al relleno
16

julia> sizeof(Int64) + sizeof(Bool) # diferente de arriba
9

Si el DataType T no tiene un tamaño específico, se lanza un error.

julia> sizeof(AbstractArray)
ERROR: El tipo abstracto AbstractArray no tiene un tamaño definido.
Stacktrace:
[...]

isconcretetype(T)

Determina si el tipo T es un tipo concreto, lo que significa que podría tener instancias directas (valores x tales que typeof(x) === T). Ten en cuenta que esto no es la negación de isabstracttype(T). Si T no es un tipo, entonces devuelve false.

Ver también: isbits, isabstracttype, issingletontype.

Ejemplos

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

julia> isconcretetype(Vector{Complex{Float32}})
true

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false

isbits(x)

Devuelve true si x es una instancia de un tipo isbitstype.

isbitstype(T)

Devuelve true si el tipo T es un tipo de "datos simples", lo que significa que es inmutable y no contiene referencias a otros valores, solo tipos primitivos y otros tipos isbitstype. Ejemplos típicos son tipos numéricos como UInt8, Float64 y Complex{Float64}. Esta categoría de tipos es significativa ya que son válidos como parámetros de tipo, pueden no rastrear el estado de isdefined / isassigned, y tienen un diseño definido que es compatible con C. Si T no es un tipo, entonces devuelve false.

Véase también isbits, isprimitivetype, ismutable.

Ejemplos

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

fieldoffset(tipo, i)

El desplazamiento en bytes del campo i de un tipo en relación con el inicio de los datos. Por ejemplo, podríamos usarlo de la siguiente manera para resumir información sobre una estructura:

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:fieldcount(T)];

julia> structinfo(Base.Filesystem.StatStruct)
13-element Vector{Tuple{UInt64, Symbol, Type}}:
 (0x0000000000000000, :desc, Union{RawFD, String})
 (0x0000000000000008, :device, UInt64)
 (0x0000000000000010, :inode, UInt64)
 (0x0000000000000018, :mode, UInt64)
 (0x0000000000000020, :nlink, Int64)
 (0x0000000000000028, :uid, UInt64)
 (0x0000000000000030, :gid, UInt64)
 (0x0000000000000038, :rdev, UInt64)
 (0x0000000000000040, :size, Int64)
 (0x0000000000000048, :blksize, Int64)
 (0x0000000000000050, :blocks, Int64)
 (0x0000000000000058, :mtime, Float64)
 (0x0000000000000060, :ctime, Float64)

Base.datatype_alignment(dt::DataType) -> Int

Alineación mínima de la asignación de memoria para instancias de este tipo. Se puede llamar en cualquier isconcretetype, aunque para Memory dará la alineación de los elementos, no del objeto completo.

Base.datatype_haspadding(dt::DataType) -> Bool

Devuelve si los campos de las instancias de este tipo están empaquetados en memoria, sin bits de relleno intermedios (definidos como bits cuyo valor no impacta de manera única en la prueba de igualdad cuando se aplica a los campos de la estructura). Se puede llamar a cualquier isconcretetype.

Base.datatype_pointerfree(dt::DataType) -> Bool

Devuelve si las instancias de este tipo pueden contener referencias a memoria gestionada por el recolector de basura. Se puede llamar en cualquier isconcretetype.

typemin(T)

El valor más bajo que se puede representar con el tipo de dato numérico (real) dado T.

Véase también: floatmin, typemax, eps.

Ejemplos

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # el número de punto flotante Float32 finito más pequeño
-3.4028235f38

typemax(T)

El valor más alto que se puede representar con el DataType numérico (real) dado.

Véase también: floatmax, typemin, eps.

Ejemplos

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # el número de punto flotante Finito más grande de Float32
3.4028235f38

floatmin(T = Float64)

Devuelve el número normal positivo más pequeño que se puede representar con el tipo de punto flotante T.

Ejemplos

julia> floatmin(Float16)
Float16(6.104e-5)

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

Devuelve el número finito más grande que se puede representar con el tipo de punto flotante T.

Véase también: typemax, floatmin, eps.

Ejemplos

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

El número de punto flotante con valor entero consecutivo más grande que está representado exactamente en el tipo de punto flotante dado T (que por defecto es Float64).

Es decir, maxintfloat devuelve el número de punto flotante con valor entero positivo más pequeño n tal que n+1 no es representable exactamente en el tipo T.

Cuando se necesita un valor de tipo Integer, usa Integer(maxintfloat(T)).

maxintfloat(T, S)

El mayor entero consecutivo representable en el tipo de punto flotante dado T que tampoco excede el máximo entero representable por el tipo entero S. De manera equivalente, es el mínimo de maxintfloat(T) y typemax(S).

eps(::Type{T}) donde T<:AbstractFloat
eps()

Devuelve el epsilon de máquina del tipo de punto flotante T (T = Float64 por defecto). Esto se define como la brecha entre 1 y el siguiente valor más grande representable por typeof(one(T)), y es equivalente a eps(one(T)). (Dado que eps(T) es un límite en el error relativo de T, es una cantidad "sin dimensiones" como one.)

Ejemplos

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

eps(x::AbstractFloat)

Devuelve la unidad en la última posición (ulp) de x. Esta es la distancia entre los valores de punto flotante representables consecutivos en x. En la mayoría de los casos, si la distancia a cada lado de x es diferente, se toma el mayor de los dos, es decir,

eps(x) == max(x-prevfloat(x), nextfloat(x)-x)

Las excepciones a esta regla son los valores finitos más pequeños y más grandes (por ejemplo, nextfloat(-Inf) y prevfloat(Inf) para Float64), que redondean al menor de los valores.

La razón de este comportamiento es que eps limita el error de redondeo de punto flotante. Bajo el modo de redondeo predeterminado RoundNearest, si $y$ es un número real y $x$ es el número de punto flotante más cercano a $y$, entonces

\[|y-x| \leq \operatorname{eps}(x)/2.\]

Véase también: nextfloat, issubnormal, floatmax.

Ejemplos

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # mayor Float64 finito
1.7976931348623157e308

julia> x + eps(x)/2            # redondea hacia arriba
Inf

julia> x + prevfloat(eps(x)/2) # redondea hacia abajo
1.7976931348623157e308

instances(T::Type)

Devuelve una colección de todas las instancias del tipo dado, si es aplicable. Principalmente utilizado para tipos enumerados (ver @enum).

Ejemplos

julia> @enum Color red blue green

julia> instances(Color)
(red, blue, green)

Any::DataType

Any es la unión de todos los tipos. Tiene la propiedad definitoria isa(x, Any) == true para cualquier x. Por lo tanto, Any describe todo el universo de valores posibles. Por ejemplo, Integer es un subconjunto de Any que incluye Int, Int8 y otros tipos de enteros.

Union{Tipos...}

Un tipo Union es un tipo abstracto que incluye todas las instancias de cualquiera de sus tipos de argumento. Esto significa que T <: Union{T,S} y S <: Union{T,S}.

Al igual que otros tipos abstractos, no se puede instanciar, incluso si todos sus argumentos no son abstractos.

Ejemplos

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString # instancia de Int está incluida en la unión
true

julia> "¡Hola!" isa IntOrString # String también está incluido
true

julia> 1.0 isa IntOrString # Float64 no está incluido porque no es ni Int ni AbstractString
false

Ayuda Extendida

A diferencia de la mayoría de los otros tipos paramétricos, las uniones son covariantes en sus parámetros. Por ejemplo, Union{Real, String} es un subtipo de Union{Number, AbstractString}.

La unión vacía Union{} es el tipo inferior de Julia.

Union{}

Union{}, el vacío Union de tipos, es el tipo que no tiene valores. Es decir, tiene la propiedad definitoria isa(x, Union{}) == false para cualquier x. Base.Bottom se define como su alias y el tipo de Union{} es Core.TypeofBottom.

Ejemplos

julia> isa(nothing, Union{})
false

UnionAll

Una unión de tipos sobre todos los valores de un parámetro de tipo. UnionAll se utiliza para describir tipos paramétricos donde los valores de algunos parámetros no son conocidos. Consulte la sección del manual sobre UnionAll Types.

Ejemplos

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

Una tupla es un contenedor de longitud fija que puede contener cualquier valor de diferentes tipos, pero no se puede modificar (es inmutable). Los valores se pueden acceder mediante indexación. Los literales de tupla se escriben con comas y paréntesis:

julia> (1, 1+1)
(1, 2)

julia> (1,)
(1,)

julia> x = (0.0, "hello", 6*7)
(0.0, "hello", 42)

julia> x[2]
"hello"

julia> typeof(x)
Tuple{Float64, String, Int64}

Una tupla de longitud 1 debe escribirse con una coma, (1,), ya que (1) sería solo un valor entre paréntesis. () representa la tupla vacía (de longitud 0).

Una tupla se puede construir a partir de un iterador utilizando un tipo Tuple como constructor:

julia> Tuple(["a", 1])
("a", 1)

julia> Tuple{String, Float64}(["a", 1])
("a", 1.0)

Los tipos de tupla son covariantes en sus parámetros: Tuple{Int} es un subtipo de Tuple{Any}. Por lo tanto, Tuple{Any} se considera un tipo abstracto, y los tipos de tupla son concretos solo si sus parámetros lo son. Las tuplas no tienen nombres de campo; los campos solo se acceden por índice. Los tipos de tupla pueden tener cualquier número de parámetros.

Consulta la sección del manual sobre Tipos de Tupla.

Consulta también Vararg, NTuple, ntuple, tuple, NamedTuple.

NTuple{N, T}

Una forma compacta de representar el tipo para una tupla de longitud N donde todos los elementos son del tipo T.

Ejemplos

julia> isa((1, 2, 3, 4, 5, 6), NTuple{6, Int})
true

Ver también ntuple.

NamedTuple

Los NamedTuples son, como su nombre sugiere, Tuples nombrados. Es decir, son una colección de valores similar a una tupla, donde cada entrada tiene un nombre único, representado como un Symbol. Al igual que los Tuples, los NamedTuples son inmutables; ni los nombres ni los valores pueden ser modificados en su lugar después de la construcción.

Un tuple nombrado se puede crear como un literal de tupla con claves, por ejemplo, (a=1, b=2), o como un literal de tupla con un punto y coma después del paréntesis de apertura, por ejemplo, (; a=1, b=2) (esta forma también acepta nombres generados programáticamente como se describe a continuación), o utilizando un tipo NamedTuple como constructor, por ejemplo, NamedTuple{(:a, :b)}((1,2)).

Acceder al valor asociado con un nombre en un tuple nombrado se puede hacer utilizando la sintaxis de acceso a campos, por ejemplo, x.a, o utilizando getindex, por ejemplo, x[:a] o x[(:a, :b)]. Un tuple de los nombres se puede obtener utilizando keys, y un tuple de los valores se puede obtener utilizando values.

El macro @NamedTuple se puede usar para declarar convenientemente tipos NamedTuple.

Ejemplos

julia> x = (a=1, b=2)
(a = 1, b = 2)

julia> x.a
1

julia> x[:a]
1

julia> x[(:a,)]
(a = 1,)

julia> keys(x)
(:a, :b)

julia> values(x)
(1, 2)

julia> collect(x)
2-element Vector{Int64}:
 1
 2

julia> collect(pairs(x))
2-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2

De manera similar a cómo se pueden definir argumentos de palabra clave programáticamente, un tuple nombrado se puede crear dando pares name::Symbol => value después de un punto y coma dentro de un literal de tupla. Esta sintaxis y la sintaxis name=value se pueden mezclar:

julia> (; :a => 1, :b => 2, c=3)
(a = 1, b = 2, c = 3)

Los pares nombre-valor también se pueden proporcionar desglosando un tuple nombrado o cualquier iterador que produzca colecciones de dos valores que contengan cada uno un símbolo como primer valor:

julia> keys = (:a, :b, :c); values = (1, 2, 3);

julia> NamedTuple{keys}(values)
(a = 1, b = 2, c = 3)

julia> (; (keys .=> values)...)
(a = 1, b = 2, c = 3)

julia> nt1 = (a=1, b=2);

julia> nt2 = (c=3, d=4);

julia> (; nt1..., nt2..., b=20) # el último b sobrescribe el valor de nt1
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip produce tuplas como (:a, 1)
(a = 1, b = 2, c = 3)

Al igual que en los argumentos de palabra clave, los identificadores y las expresiones de punto implican nombres:

julia> x = 0
0

julia> t = (; x)
(x = 0,)

julia> (; t.x)
(x = 0,)

@NamedTuple{key1::Type1, key2::Type2, ...}
@NamedTuple begin key1::Type1; key2::Type2; ...; end

Este macro proporciona una sintaxis más conveniente para declarar tipos NamedTuple. Devuelve un tipo NamedTuple con las claves y tipos dados, equivalente a NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}}. Si se omite la declaración ::Type, se toma como Any. La forma begin ... end permite que las declaraciones se dividan en múltiples líneas (similar a una declaración de struct), pero es equivalente de otro modo. El macro NamedTuple se utiliza al imprimir tipos NamedTuple en, por ejemplo, el REPL.

Por ejemplo, la tupla (a=3.1, b="hello") tiene un tipo NamedTuple{(:a, :b), Tuple{Float64, String}}, que también se puede declarar a través de @NamedTuple como:

julia> @NamedTuple{a::Float64, b::String}
@NamedTuple{a::Float64, b::String}

julia> @NamedTuple begin
           a::Float64
           b::String
       end
@NamedTuple{a::Float64, b::String}

@Kwargs{key1::Type1, key2::Type2, ...}

Este macro proporciona una forma conveniente de construir la representación de tipo de argumentos de palabra clave a partir de la misma sintaxis que @NamedTuple. Por ejemplo, cuando tenemos una llamada a función como func([argumentos posicionales]; kw1=1.0, kw2="2"), podemos usar este macro para construir la representación interna de tipo de los argumentos de palabra clave como @Kwargs{kw1::Float64, kw2::String}. La sintaxis del macro está diseñada específicamente para simplificar el tipo de firma de un método de palabra clave cuando se imprime en la vista de traza de pila.

julia> @Kwargs{init::Int} # la representación interna de los argumentos de palabra clave
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
La función `+` existe, pero no se define ningún método para esta combinación de tipos de argumento.

Los candidatos más cercanos son:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

Stacktrace:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [inlined]
  [3] _foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, init::Int64, itr::String)
    @ Base ./reduce.jl:62
  [4] foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, nt::Int64, itr::String)
    @ Base ./reduce.jl:48 [inlined]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [inlined]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [inlined]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [inlined]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [inlined]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [inlined]
 [10] top-level scope
    @ REPL[12]:1

Val(c)

Devuelve Val{c}(), que no contiene datos en tiempo de ejecución. Tipos como este se pueden usar para pasar la información entre funciones a través del valor c, que debe ser un valor isbits o un Symbol. La intención de esta construcción es poder despachar sobre constantes directamente (en tiempo de compilación) sin tener que probar el valor de la constante en tiempo de ejecución.

Ejemplos

julia> f(::Val{true}) = "Good"
f (función genérica con 1 método)

julia> f(::Val{false}) = "Bad"
f (función genérica con 2 métodos)

julia> f(Val(true))
"Good"

Vararg{T,N}

El último parámetro de un tipo de tupla Tuple puede ser el valor especial Vararg, que denota cualquier número de elementos finales. Vararg{T,N} corresponde exactamente a N elementos del tipo T. Finalmente, Vararg{T} corresponde a cero o más elementos del tipo T. Los tipos de tupla Vararg se utilizan para representar los argumentos aceptados por los métodos de varargs (ver la sección sobre Funciones Varargs en el manual).

Véase también NTuple.

Ejemplos

julia> mytupletype = Tuple{AbstractString, Vararg{Int}}
Tuple{AbstractString, Vararg{Int64}}

julia> isa(("1",), mytupletype)
true

julia> isa(("1",1), mytupletype)
true

julia> isa(("1",1,2), mytupletype)
true

julia> isa(("1",1,2,3.0), mytupletype)
false

Nada

Un tipo sin campos que es el tipo de nothing.

Véase también: isnothing, Some, Missing.

isnothing(x)

Devuelve true si x === nothing, y devuelve false si no.

Véase también something, Base.notnothing, ismissing.

notnothing(x)

Lanza un error si x === nothing, y devuelve x si no.

Some{T}

Un tipo de envoltura utilizado en Union{Some{T}, Nothing} para distinguir entre la ausencia de un valor (nothing) y la presencia de un valor nothing (es decir, Some(nothing)).

Utiliza something para acceder al valor envuelto por un objeto Some.

algo(x...)

Devuelve el primer valor en los argumentos que no sea igual a nothing, si lo hay. De lo contrario, lanza un error. Los argumentos de tipo Some se desenvuelven.

Véase también coalesce, skipmissing, @something.

Ejemplos

julia> algo(nothing, 1)
1

julia> algo(Some(1), nothing)
1

julia> algo(Some(nothing), 2) === nothing
true

julia> algo(missing, nothing)
missing

julia> algo(nothing, nothing)
ERROR: ArgumentError: No hay argumentos de valor presentes

@something(x...)

Versión de cortocircuito de something.

Ejemplos

julia> f(x) = (println("f($x)"); nothing);

julia> a = 1;

julia> a = @something a f(2) f(3) error("No se puede encontrar un valor predeterminado para `a`")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("No se puede encontrar un valor predeterminado para `b`")
f(2)
f(3)
ERROR: No se puede encontrar un valor predeterminado para `b`
[...]

julia> b = @something b f(2) f(3) Some(nothing)
f(2)
f(3)

julia> b === nothing
true

Enum{T<:Integer}

El supertipo abstracto de todos los tipos enumerados definidos con @enum.

@enum EnumName[::BaseType] value1[=x] value2[=y]

Crea un subtipo Enum{BaseType} con el nombre EnumName y valores de miembros de enumeración value1 y value2 con valores asignados opcionales de x y y, respectivamente. EnumName se puede usar como otros tipos y los valores de los miembros de enumeración como valores regulares, como

Ejemplos

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "Soy una fruta con valor: $(Int(x))"
f (función genérica con 1 método)

julia> f(apple)
"Soy una fruta con valor: 1"

julia> Fruit(1)
apple::Fruit = 1

Los valores también se pueden especificar dentro de un bloque begin, por ejemplo:

@enum EnumName begin
    value1
    value2
end

BaseType, que por defecto es Int32, debe ser un subtipo primitivo de Integer. Los valores de los miembros se pueden convertir entre el tipo de enumeración y BaseType. read y write realizan estas conversiones automáticamente. En caso de que la enumeración se cree con un BaseType no predeterminado, Integer(value1) devolverá el entero value1 con el tipo BaseType.

Para listar todas las instancias de una enumeración, usa instances, por ejemplo:

julia> instances(Fruit)
(apple, orange, kiwi)

Es posible construir un símbolo a partir de una instancia de enumeración:

julia> Symbol(apple)
:apple

Expr(head::Symbol, args...)

Un tipo que representa expresiones compuestas en código julia analizado (ASTs). Cada expresión consiste en un head Symbol que identifica qué tipo de expresión es (por ejemplo, una llamada, un bucle for, una declaración condicional, etc.), y subexpresiones (por ejemplo, los argumentos de una llamada). Las subexpresiones se almacenan en un campo Vector{Any} llamado args.

Consulta el capítulo del manual sobre Metaprogramación y la documentación para desarrolladores Julia ASTs.

Ejemplos

julia> Expr(:call, :+, 1, 2)
:(1 + 2)

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c

Símbolo

El tipo de objeto utilizado para representar identificadores en el código julia analizado (ASTs). También se utiliza a menudo como un nombre o etiqueta para identificar una entidad (por ejemplo, como una clave de diccionario). Los Símbolos se pueden ingresar utilizando el operador de cita ::

julia> :name
:name

julia> typeof(:name)
Símbolo

julia> x = 42
42

julia> eval(:x)
42

Los Símbolos también se pueden construir a partir de cadenas u otros valores llamando al constructor Symbol(x...).

Los Símbolos son inmutables y su implementación reutiliza el mismo objeto para todos los Símbolos con el mismo nombre.

A diferencia de las cadenas, los Símbolos son entidades "atómicas" o "escalares" que no admiten iteración sobre caracteres.

Symbol(x...) -> Symbol

Crea un Symbol concatenando las representaciones en cadena de los argumentos.

Ejemplos

julia> Symbol("my", "name")
:myname

julia> Symbol("day", 4)
:day4

Módulo

Un Módulo es un espacio de trabajo de variables globales separado. Consulta module y la sección del manual sobre módulos para más detalles.

Module(name::Symbol=:anonymous, std_imports=true, default_names=true)

Devuelve un módulo con el nombre especificado. Un baremodule corresponde a Module(:ModuleName, false)

Se puede crear un módulo vacío que no contenga nombres en absoluto con Module(:ModuleName, false, false). Este módulo no importará Base ni Core y no contiene una referencia a sí mismo.

Función

Tipo abstracto de todas las funciones.

Ejemplos

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (tipo singleton de la función sin, subtipo de Function)

julia> ans <: Function
true

hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter()) -> Bool

Determina si la función genérica dada tiene un método que coincide con el Tuple de tipos de argumento dados con el límite superior de la edad del mundo dado por world.

Si se proporciona un tuple de nombres de argumentos clave kwnames, esto también verifica si el método de f que coincide con t tiene los nombres de argumentos clave dados. Si el método coincidente acepta un número variable de argumentos clave, por ejemplo, con kwargs..., cualquier nombre dado en kwnames se considera válido. De lo contrario, los nombres proporcionados deben ser un subconjunto de los argumentos clave del método.

Véase también applicable.

Ejemplos

julia> hasmethod(length, Tuple{Array})
true

julia> f(; oranges=0) = oranges;

julia> hasmethod(f, Tuple{}, (:oranges,))
true

julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false

julia> g(; xs...) = 4;

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g acepta kwargs arbitrarios
true

applicable(f, args...) -> Bool

Determina si la función genérica dada tiene un método aplicable a los argumentos dados.

Ver también hasmethod.

Ejemplos

julia> function f(x, y)
           x + y
       end;

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Base.isambiguous(m1, m2; ambiguous_bottom=false) -> Bool

Determina si dos métodos m1 y m2 pueden ser ambiguos para alguna firma de llamada. Esta prueba se realiza en el contexto de otros métodos de la misma función; de forma aislada, m1 y m2 podrían ser ambiguos, pero si se ha definido un tercer método que resuelve la ambigüedad, esto devuelve false. Alternativamente, de forma aislada m1 y m2 podrían estar ordenados, pero si un tercer método no puede ser ordenado con ellos, pueden causar una ambigüedad juntos.

Para tipos paramétricos, el argumento clave ambiguous_bottom controla si Union{} cuenta como una intersección ambigua de parámetros de tipo: cuando es true, se considera ambigua; cuando es false, no lo es.

Ejemplos

julia> foo(x::Complex{<:Integer}) = 1
foo (función genérica con 1 método)

julia> foo(x::Complex{<:Rational}) = 2
foo (función genérica con 2 métodos)

julia> m1, m2 = collect(methods(foo));

julia> typeintersect(m1.sig, m2.sig)
Tuple{typeof(foo), Complex{Union{}}}

julia> Base.isambiguous(m1, m2, ambiguous_bottom=true)
true

julia> Base.isambiguous(m1, m2, ambiguous_bottom=false)
false

invoke(f, argtypes::Type, args...; kwargs...)

Invoca un método para la función genérica dada f que coincide con los tipos especificados argtypes en los argumentos especificados args y pasando los argumentos de palabra clave kwargs. Los argumentos args deben conformarse con los tipos especificados en argtypes, es decir, la conversión no se realiza automáticamente. Este método permite invocar un método que no sea el método más específico que coincide, lo cual es útil cuando se necesita explícitamente el comportamiento de una definición más general (a menudo como parte de la implementación de un método más específico de la misma función).

Ten cuidado al usar invoke para funciones que no escribes. Qué definición se utiliza para los argtypes dados es un detalle de implementación a menos que la función indique explícitamente que llamar con ciertos argtypes es parte de la API pública. Por ejemplo, el cambio entre f1 y f2 en el ejemplo a continuación se considera generalmente compatible porque el cambio es invisible para el llamador con una llamada normal (no invoke). Sin embargo, el cambio es visible si usas invoke.

Ejemplos

julia> f(x::Real) = x^2;

julia> f(x::Integer) = 1 + invoke(f, Tuple{Real}, x);

julia> f(2)
5

julia> f1(::Integer) = Integer
       f1(::Real) = Real;

julia> f2(x::Real) = _f2(x)
       _f2(::Integer) = Integer
       _f2(_) = Real;

julia> f1(1)
Integer

julia> f2(1)
Integer

julia> invoke(f1, Tuple{Real}, 1)
Real

julia> invoke(f2, Tuple{Real}, 1)
Integer

@invoke f(arg::T, ...; kwargs...)

Proporciona una forma conveniente de llamar a invoke al expandir @invoke f(arg1::T1, arg2::T2; kwargs...) a invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...). Cuando se omite la anotación de tipo de un argumento, se reemplaza por Core.Typeof de ese argumento. Para invocar un método donde un argumento no tiene tipo o está explícitamente tipado como Any, anota el argumento con ::Any.

También admite la siguiente sintaxis:

• @invoke (x::X).f se expande a invoke(getproperty, Tuple{X,Symbol}, x, :f)
• @invoke (x::X).f = v::V se expande a invoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v)
• @invoke (xs::Xs)[i::I] se expande a invoke(getindex, Tuple{Xs,I}, xs, i)
• @invoke (xs::Xs)[i::I] = v::V se expande a invoke(setindex!, Tuple{Xs,V,I}, xs, v, i)

Ejemplos

julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))

julia> @invoke 420::Integer % Unsigned
0x00000000000001a4

julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Tuple{X, Core.Typeof(:f)}, x, :f))

julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Tuple{X, Core.Typeof(:f), V}, x, :f, v))

julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Tuple{Xs, I}, xs, i))

julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Tuple{Xs, V, I}, xs, v, i))

invokelatest(f, args...; kwargs...)

Llama a f(args...; kwargs...), pero garantiza que se ejecutará el método más reciente de f. Esto es útil en circunstancias especializadas, por ejemplo, bucles de eventos de larga duración o funciones de devolución de llamada que pueden llamar a versiones obsoletas de una función f. (La desventaja es que invokelatest es algo más lento que llamar a f directamente, y el tipo del resultado no puede ser inferido por el compilador.)

@invokelatest f(args...; kwargs...)

Proporciona una forma conveniente de llamar a invokelatest. @invokelatest f(args...; kwargs...) simplemente se expandirá en Base.invokelatest(f, args...; kwargs...).

También admite la siguiente sintaxis:

• @invokelatest x.f se expande a Base.invokelatest(getproperty, x, :f)
• @invokelatest x.f = v se expande a Base.invokelatest(setproperty!, x, :f, v)
• @invokelatest xs[i] se expande a Base.invokelatest(getindex, xs, i)
• @invokelatest xs[i] = v se expande a Base.invokelatest(setindex!, xs, v, i)

julia> @macroexpand @invokelatest f(x; kw=kwv)
:(Base.invokelatest(f, x; kw = kwv))

julia> @macroexpand @invokelatest x.f
:(Base.invokelatest(Base.getproperty, x, :f))

julia> @macroexpand @invokelatest x.f = v
:(Base.invokelatest(Base.setproperty!, x, :f, v))

julia> @macroexpand @invokelatest xs[i]
:(Base.invokelatest(Base.getindex, xs, i))

julia> @macroexpand @invokelatest xs[i] = v
:(Base.invokelatest(Base.setindex!, xs, v, i))

new, or new{A,B,...}

Función especial disponible para constructores internos que crea un nuevo objeto del tipo. La forma new{A,B,...} especifica explícitamente los valores de los parámetros para tipos paramétricos. Consulte la sección del manual sobre Inner Constructor Methods para más información.

|>(x, f)

Operador infijo que aplica la función f al argumento x. Esto permite que f(g(x)) se escriba como x |> g |> f. Cuando se usa con funciones anónimas, generalmente se requieren paréntesis alrededor de la definición para obtener la cadena deseada.

Ejemplos

julia> 4 |> inv
0.25

julia> [2, 3, 5] |> sum |> inv
0.1

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14

f ∘ g

Componer funciones: es decir, (f ∘ g)(args...; kwargs...) significa f(g(args...; kwargs...)). El símbolo ∘ se puede ingresar en el REPL de Julia (y en la mayoría de los editores, configurados adecuadamente) escribiendo \circ<tab>.

La composición de funciones también funciona en forma de prefijo: ∘(f, g) es lo mismo que f ∘ g. La forma de prefijo admite la composición de múltiples funciones: ∘(f, g, h) = f ∘ g ∘ h y el splatting ∘(fs...) para componer una colección iterable de funciones. El último argumento de ∘ se ejecuta primero.

Ejemplos

julia> map(uppercase∘first, ["apple", "banana", "carrot"])
3-element Vector{Char}:
 'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
 'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
 'C': ASCII/Unicode U+0043 (category Lu: Letter, uppercase)

julia> (==(6)∘length).(["apple", "banana", "carrot"])
3-element BitVector:
 0
 1
 1

julia> fs = [
           x -> 2x
           x -> x-1
           x -> x/2
           x -> x+1
       ];

julia> ∘(fs...)(3)
2.0

Ver también ComposedFunction, !f::Function.

ComposedFunction{Outer,Inner} <: Function

Representa la composición de dos objetos llamables outer::Outer y inner::Inner. Es decir

ComposedFunction(outer, inner)(args...; kw...) === outer(inner(args...; kw...))

La forma preferida de construir una instancia de ComposedFunction es usar el operador de composición ∘:

julia> sin ∘ cos === ComposedFunction(sin, cos)
true

julia> typeof(sin∘cos)
ComposedFunction{typeof(sin), typeof(cos)}

Las piezas compuestas se almacenan en los campos de ComposedFunction y se pueden recuperar de la siguiente manera:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

Ver también ∘.

splat(f)

Equivalente a

    my_splat(f) = args->f(args...)

es decir, dado una función, devuelve una nueva función que toma un argumento y lo expande en la función original. Esto es útil como un adaptador para pasar una función de múltiples argumentos en un contexto que espera un solo argumento, pero pasa una tupla como ese único argumento.

Ejemplos

julia> map(splat(+), zip(1:3,4:6))
3-element Vector{Int64}:
 5
 7
 9

julia> my_add = splat(+)
splat(+)

julia> my_add((1,2,3))
6

Fix1(f, x)

Un tipo que representa una versión parcialmente aplicada de la función de dos argumentos f, con el primer argumento fijado al valor "x". En otras palabras, Fix1(f, x) se comporta de manera similar a y->f(x, y).

Véase también Fix2.

Fix2(f, x)

Un tipo que representa una versión parcialmente aplicada de la función de dos argumentos f, con el segundo argumento fijado al valor "x". En otras palabras, Fix2(f, x) se comporta de manera similar a y->f(y, x).

Core.eval(m::Module, expr)

Evalúa una expresión en el módulo dado y devuelve el resultado.

eval(expr)

Evalúa una expresión en el ámbito global del módulo que la contiene. Cada Module (excepto aquellos definidos con baremodule) tiene su propia definición de eval con un argumento, que evalúa expresiones en ese módulo.

@eval [mod,] ex

Evalúa una expresión con valores interpolados en ella usando eval. Si se proporcionan dos argumentos, el primero es el módulo en el que se evalúa.

evalfile(path::AbstractString, args::Vector{String}=String[])

Carga el archivo en un módulo anónimo usando include, evalúa todas las expresiones y devuelve el valor de la última expresión. El argumento opcional args se puede usar para establecer los argumentos de entrada del script (es decir, la variable global ARGS). Ten en cuenta que las definiciones (por ejemplo, métodos, globales) se evalúan en el módulo anónimo y no afectan al módulo actual.

Ejemplos

julia> write("testfile.jl", """
           @show ARGS
           1 + 1
       """);

julia> x = evalfile("testfile.jl", ["ARG1", "ARG2"]);
ARGS = ["ARG1", "ARG2"]

julia> x
2

julia> rm("testfile.jl")

esc(e)

Solo válido en el contexto de un Expr devuelto por un macro. Previene que el paso de higiene del macro convierta las variables incrustadas en variables gensym. Consulta la sección de Macros del capítulo de Metaprogramación del manual para más detalles y ejemplos.

@inbounds(blk)

Elimina la verificación de límites de matriz dentro de las expresiones.

En el ejemplo a continuación, se omite la verificación de rango para referenciar el elemento i de la matriz A para mejorar el rendimiento.

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i in eachindex(A)
        @inbounds r += A[i]
    end
    return r
end

@boundscheck(blk)

Anota la expresión blk como un bloque de verificación de límites, permitiendo que sea elidido por @inbounds.

Ejemplos

julia> @inline function g(A, i)
           @boundscheck checkbounds(A, i)
           return "accediendo ($A)[$i]"
       end;

julia> f1() = return g(1:2, -1);

julia> f2() = @inbounds return g(1:2, -1);

julia> f1()
ERROR: BoundsError: intento de acceder a UnitRange{Int64} de 2 elementos en el índice [-1]
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inlined]
 [3] g at ./none:2 [inlined]
 [4] f1() at ./none:1
 [5] top-level scope

julia> f2()
"accediendo (1:2)[-1]"

@propagate_inbounds

Indica al compilador que inserte una función en línea mientras retiene el contexto de inbounds del llamador.

@inline

Dale una pista al compilador de que esta función merece ser inlined.

Las funciones pequeñas típicamente no necesitan la anotación @inline, ya que el compilador lo hace automáticamente. Al usar @inline en funciones más grandes, se puede dar un empujón adicional al compilador para que las inlined.

@inline se puede aplicar inmediatamente antes de una definición de función o dentro de un cuerpo de función.

# anotar definición de forma larga
@inline function longdef(x)
    ...
end

# anotar definición de forma corta
@inline shortdef(x) = ...

# anotar función anónima que crea un bloque `do`
f() do
    @inline
    ...
end

@inline block

Dale una pista al compilador de que las llamadas dentro de block merecen ser inlined.

# El compilador intentará inlined `f`
@inline f(...)

# El compilador intentará inlined `f`, `g` y `+`
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # cuerpo
end

let
    @inline explicit_noinline(args...) # será inlined
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # el compilador intentará inlined esta llamada
    b = f(b0)          # el compilador NO intentará inlined esta llamada
    return a, b
end

@noinline

Dale una pista al compilador de que no debe inlining una función.

Las funciones pequeñas se inlinan automáticamente. Al usar @noinline en funciones pequeñas, se puede prevenir el auto-inlining.

@noinline se puede aplicar inmediatamente antes de una definición de función o dentro de un cuerpo de función.

# anotar definición de forma larga
@noinline function longdef(x)
    ...
end

# anotar definición de forma corta
@noinline shortdef(x) = ...

# anotar función anónima que crea un bloque `do`
f() do
    @noinline
    ...
end

@noinline block

Dale una pista al compilador de que no debe inlining las llamadas dentro de block.

# El compilador intentará no inlining `f`
@noinline f(...)

# El compilador intentará no inlining `f`, `g` y `+`
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # cuerpo
end

let
    @noinline explicit_inline(args...) # no será inlined
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # el compilador NO intentará inlining esta llamada
    b = f(b0)            # el compilador intentará inlining esta llamada
    return a, b
end

@nospecialize

Aplicado a un nombre de argumento de función, indica al compilador que la implementación del método no debe especializarse para diferentes tipos de ese argumento, sino que debe utilizar el tipo declarado para ese argumento. Se puede aplicar a un argumento dentro de una lista de argumentos formal, o en el cuerpo de la función. Cuando se aplica a un argumento, el macro debe envolver toda la expresión del argumento, por ejemplo, @nospecialize(x::Real) o @nospecialize(i::Integer...) en lugar de envolver solo el nombre del argumento. Cuando se usa en el cuerpo de una función, el macro debe ocurrir en posición de declaración y antes de cualquier código.

Cuando se usa sin argumentos, se aplica a todos los argumentos del ámbito padre. En el ámbito local, esto significa todos los argumentos de la función que contiene. En el ámbito global (de nivel superior), esto significa todos los métodos definidos posteriormente en el módulo actual.

La especialización se puede restablecer a la predeterminada utilizando @specialize.

function example_function(@nospecialize x)
    ...
end

function example_function(x, @nospecialize(y = 1))
    ...
end

function example_function(x, y, z)
    @nospecialize x y
    ...
end

@nospecialize
f(y) = [x for x in y]
@specialize

Ejemplos

julia> f(A::AbstractArray) = g(A)
f (función genérica con 1 método)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (función genérica con 1 método)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Float64
└──      return %1
) => Float64

Aquí, la anotación @nospecialize resulta en el equivalente de

f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)

asegurando que solo se generará una versión del código nativo para g, una que sea genérica para cualquier AbstractArray. Sin embargo, el tipo de retorno específico aún se infiere para ambos, g y f, y esto todavía se utiliza para optimizar los llamadores de f y g.

@specialize

Restablece la sugerencia de especialización para un argumento a la predeterminada. Para más detalles, consulta @nospecialize.

Base.@nospecializeinfer function f(args...)
    @nospecialize ...
    ...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...

Indica al compilador que infiera f utilizando los tipos declarados de los argumentos @nospecialized. Esto se puede usar para limitar el número de especializaciones generadas por el compilador durante la inferencia.

Ejemplos

julia> f(A::AbstractArray) = g(A)
f (función genérica con 1 método)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (función genérica con 1 método)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Any
└──      return %1
) => Any

En este ejemplo, f será inferido para cada tipo específico de A, pero g solo será inferido una vez con el tipo de argumento declarado A::AbstractArray, lo que significa que el compilador probablemente no verá el tiempo excesivo de inferencia en él mientras no puede inferir el tipo de retorno concreto. Sin el @nospecializeinfer, f([1.0]) inferiría el tipo de retorno de g como Float64, indicando que la inferencia se ejecutó para g(::Vector{Float64}) a pesar de la prohibición de la generación de código especializado.

```

Base.@constprop configuración [ex]

Controla el modo de propagación de constantes interprocedimental para la función anotada.

Se admiten dos configuraciones:

• Base.@constprop :agresivo [ex]: aplica la propagación de constantes de manera agresiva. Para un método donde el tipo de retorno depende del valor de los argumentos, esto puede generar mejores resultados de inferencia a costa de un tiempo de compilación adicional.
• Base.@constprop :ninguno [ex]: desactiva la propagación de constantes. Esto puede reducir los tiempos de compilación para funciones que Julia de otro modo podría considerar dignas de propagación de constantes. Los casos comunes son para funciones con argumentos de tipo Bool o Symbol o argumentos de palabra clave.

Base.@constprop se puede aplicar inmediatamente antes de una definición de función o dentro de un cuerpo de función.

# anotar definición en forma larga
Base.@constprop :agresivo function longdef(x)
    ...
end

# anotar definición en forma corta
Base.@constprop :agresivo shortdef(x) = ...

# anotar función anónima que crea un bloque `do`
f() do
    Base.@constprop :agresivo
    ...
end

gensym([tag])

Genera un símbolo que no entrará en conflicto con otros nombres de variables (en el mismo módulo).

@gensym

Genera un símbolo gensym para una variable. Por ejemplo, @gensym x y se transforma en x = gensym("x"); y = gensym("y").

var

La sintaxis var"#example#" se refiere a una variable llamada Symbol("#example#"), aunque #example# no sea un nombre de identificador válido en Julia.

Esto puede ser útil para la interoperabilidad con lenguajes de programación que tienen diferentes reglas para la construcción de identificadores válidos. Por ejemplo, para referirse a la variable R draw.segments, puedes usar var"draw.segments" en tu código Julia.

También se utiliza para show el código fuente de Julia que ha pasado por la higiene de macros o que de otro modo contiene nombres de variables que no se pueden analizar normalmente.

Ten en cuenta que esta sintaxis requiere soporte del analizador, por lo que se expande directamente por el analizador en lugar de implementarse como una macro de cadena normal @var_str.

@goto name

@goto name salta incondicionalmente a la declaración en la ubicación @label name.

@label y @goto no pueden crear saltos a diferentes declaraciones de nivel superior. Los intentos causan un error. Para seguir usando @goto, encierra @label y @goto en un bloque.

@label name

Etiqueta una declaración con la etiqueta simbólica name. La etiqueta marca el punto final de un salto incondicional con @goto name.

@simd

Anotar un bucle for para permitir que el compilador tome libertades adicionales para permitir el reordenamiento del bucle.

El objeto iterado en un bucle @simd for debe ser un rango unidimensional. Al usar @simd, estás afirmando varias propiedades del bucle:

• Es seguro ejecutar iteraciones en un orden arbitrario o superpuesto, con especial consideración para las variables de reducción.
• Las operaciones de punto flotante sobre las variables de reducción pueden ser reordenadas o contraídas, lo que puede causar resultados diferentes que sin @simd.

En muchos casos, Julia puede vectorizar automáticamente los bucles internos sin el uso de @simd. Usar @simd le da al compilador un poco más de margen para hacerlo posible en más situaciones. En cualquier caso, tu bucle interno debe tener las siguientes propiedades para permitir la vectorización:

• El bucle debe ser un bucle más interno.
• El cuerpo del bucle debe ser código de línea recta. Por lo tanto, @inbounds es actualmente necesario para todos los accesos a arreglos. El compilador a veces puede convertir expresiones cortas &&, || y ?: en código de línea recta si es seguro evaluar todos los operandos incondicionalmente. Considera usar la función ifelse en lugar de ?: en el bucle si es seguro hacerlo.
• Los accesos deben tener un patrón de paso y no pueden ser "gathers" (lecturas de índices aleatorios) o "scatters" (escrituras de índices aleatorios).
• El paso debe ser un paso unitario.

• No existen dependencias de memoria llevadas por el bucle.
• Ninguna iteración espera nunca a que una iteración anterior avance.

@polly

Indica al compilador que aplique el optimizador poligonal Polly a una función.

@generated f

@generated se utiliza para anotar una función que será generada. En el cuerpo de la función generada, solo se pueden leer los tipos de los argumentos (no los valores). La función devuelve una expresión citada que se evalúa cuando se llama a la función. El macro @generated no debe usarse en funciones que mutan el ámbito global o dependen de elementos mutables.

Consulta Metaprogramming para más detalles.

Ejemplos

julia> @generated function bar(x)
           if x <: Integer
               return :(x ^ 2)
           else
               return :(x)
           end
       end
bar (generic function with 1 method)

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@assume_effects configurando... [ex]

Sobrescribe el modelado de efectos del compilador. Este macro se puede usar en varios contextos:

1. Inmediatamente antes de una definición de método, para sobrescribir todo el modelado de efectos del método aplicado.
2. Dentro de un cuerpo de función sin argumentos, para sobrescribir todo el modelado de efectos del método que lo contiene.
3. Aplicado a un bloque de código, para sobrescribir el modelado de efectos local del bloque de código aplicado.

Ejemplos

julia> Base.@assume_effects :terminates_locally function fact(x)
           # uso 1:
           # este :terminates_locally permite que `fact` sea evaluado como constante
           res = 1
           0 ≤ x < 20 || error("mal fact")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (función genérica con 1 método)

julia> code_typed() do
           fact(12)
       end |> only
CodeInfo(
1 ─     return 479001600
) => Int64

julia> code_typed() do
           map((2,3,4)) do x
               # uso 2:
               # este :terminates_locally permite que esta función anónima sea evaluada como constante
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("mal fact")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("mal fact")
               # uso 3:
               # con esta anotación :terminates_locally el compilador omite la contaminación
               # del efecto `:terminates` dentro de este bloque `while`, permitiendo que la función
               # anónima padre sea evaluada como constante
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

En general, cada valor de setting hace una afirmación sobre el comportamiento de la función, sin requerir que el compilador demuestre que este comportamiento es realmente cierto. Estas afirmaciones se hacen para todas las edades del mundo. Por lo tanto, es aconsejable limitar el uso de funciones genéricas que pueden extenderse más tarde para invalidar la suposición (lo que causaría un comportamiento indefinido).

Los siguientes settings son compatibles.

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :terminates_locally
• :notaskstate
• :inaccessiblememonly
• :noub
• :noub_if_noinbounds
• :nortcall
• :foldable
• :removable
• :total

Ayuda extendida

:consistent

La configuración :consistent afirma que para entradas iguales (===):

• La forma de terminación (valor de retorno, excepción, no terminación) siempre será la misma.
• Si el método retorna, los resultados siempre serán iguales.

:effect_free

La configuración :effect_free afirma que el método está libre de efectos secundarios semánticamente visibles externamente. La siguiente es una lista incompleta de efectos secundarios semánticamente visibles externamente:

• Cambiar el valor de una variable global.
• Mutar el heap (por ejemplo, un arreglo o valor mutable), excepto como se indica a continuación.
• Cambiar la tabla de métodos (por ejemplo, a través de llamadas a eval).
• Entrada/salida de archivos/red/etc.
• Cambio de tareas.

Sin embargo, lo siguiente no es semánticamente visible, incluso si puede ser observable:

• Asignaciones de memoria (tanto mutables como inmutables).
• Tiempo transcurrido.
• Recolección de basura.
• Mutaciones del heap de objetos cuya vida útil no excede el método (es decir, que fueron asignados en el método y no escapan).
• El valor devuelto (que es externamente visible, pero no un efecto secundario).

La regla general aquí es que un efecto secundario visible externamente es cualquier cosa que afectaría la ejecución del resto del programa si la función no se ejecutara.

:nothrow

La configuración :nothrow afirma que este método no lanza una excepción (es decir, siempre devolverá un valor o nunca devolverá).

:terminates_globally

La configuración :terminates_globally afirma que este método eventualmente terminará (ya sea normalmente o anormalmente), es decir, no entra en un bucle indefinido.

:terminates_locally

La configuración :terminates_locally es como :terminates_globally, excepto que solo se aplica al flujo de control sintáctico dentro del método anotado. Por lo tanto, es una afirmación mucho más débil (y por lo tanto más segura) que permite la posibilidad de no terminación si el método llama a algún otro método que no termina.

:notaskstate

La configuración :notaskstate afirma que el método no utiliza ni modifica el estado de tarea local (almacenamiento local de tarea, estado de RNG, etc.) y, por lo tanto, puede ser movido entre tareas sin resultados observables.

:inaccessiblememonly

La configuración :inaccessiblememonly afirma que el método no accede ni modifica memoria mutable accesible externamente. Esto significa que el método puede acceder o modificar memoria mutable para objetos recién asignados que no son accesibles por otros métodos o ejecución de nivel superior antes de retornar del método, pero no puede acceder ni modificar ningún estado global mutable o memoria mutable apuntada por sus argumentos.

:noub

La configuración :noub afirma que el método no ejecutará ningún comportamiento indefinido (para cualquier entrada). Tenga en cuenta que el comportamiento indefinido puede técnicamente causar que el método viole cualquier otra afirmación de efecto (como :consistent o :effect_free) también, pero no modelamos esto, y asumen la ausencia de comportamiento indefinido.

:nortcall

La configuración :nortcall afirma que el método no llama a Core.Compiler.return_type, y que cualquier otro método que este método pueda llamar tampoco llama a Core.Compiler.return_type.

:foldable

Esta configuración es un atajo conveniente para el conjunto de efectos que el compilador requiere que se garanticen para evaluar una llamada como constante en tiempo de compilación. Actualmente es equivalente a los siguientes settings:

• :consistent
• :effect_free
• :terminates_globally
• :noub
• :nortcall

:removable

Esta configuración es un atajo conveniente para el conjunto de efectos que el compilador requiere que se garanticen para eliminar una llamada cuyo resultado no se utiliza en tiempo de compilación. Actualmente es equivalente a los siguientes settings:

• :effect_free
• :nothrow
• :terminates_globally

:total

Esta configuración es el conjunto máximo posible de efectos. Actualmente implica los siguientes otros settings:

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :notaskstate
• :inaccessiblememonly
• :noub
• :nortcall

Efectos negados

Los nombres de efecto pueden ser precedidos por ! para indicar que el efecto debe ser eliminado de un efecto meta anterior. Por ejemplo, :total !:nothrow indica que, aunque la llamada es generalmente total, puede lanzar.

@deprecate old new [export_old=true]

Desaprobación del método old y especificar la llamada de reemplazo new, definiendo un nuevo método old con la firma especificada en el proceso.

Para evitar que old sea exportado, establece export_old en false.

Ver también Base.depwarn().

Ejemplos

julia> @deprecate old(x) new(x)
old (función genérica con 1 método)

julia> @deprecate old(x) new(x) false
old (función genérica con 1 método)

Las llamadas a @deprecate sin anotaciones de tipo explícitas definirán métodos desaprobados que aceptan cualquier número de argumentos posicionales y de palabras clave de tipo Any.

Para restringir la desaprobación a una firma específica, anota los argumentos de old. Por ejemplo,

julia> new(x::Int) = x;

julia> new(x::Float64) = 2x;

julia> @deprecate old(x::Int) new(x);

julia> methods(old)
# 1 método para la función genérica "old" de Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

definirá y desaprobará un método old(x::Int) que refleja new(x::Int) pero no definirá ni desaprobará el método old(x::Float64).

Base.depwarn(msg::String, funcsym::Symbol; force=false)

Imprime msg como una advertencia de deprecación. El símbolo funcsym debe ser el nombre de la función que llama, que se utiliza para asegurar que la advertencia de deprecación solo se imprima la primera vez para cada lugar de llamada. Establece force=true para forzar que la advertencia siempre se muestre, incluso si Julia se inició con --depwarn=no (el valor predeterminado).

Ver también @deprecate.

Ejemplos

function deprecated_func()
    Base.depwarn("¡No uses `deprecated_func()`!", :deprecated_func)

    1 + 1
end

Faltante

Un tipo sin campos cuya instancia única missing se utiliza para representar valores faltantes.

Ver también: skipmissing, nonmissingtype, Nothing.

missing

La instancia singleton del tipo Missing que representa un valor faltante.

Ver también: NaN, skipmissing, nonmissingtype.

coalesce(x...)

Devuelve el primer valor en los argumentos que no es igual a missing, si lo hay. De lo contrario, devuelve missing.

Véase también skipmissing, something, @coalesce.

Ejemplos

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # devuelve `nothing`

julia> coalesce(missing, missing)
missing

@coalesce(x...)

Versión de cortocircuito de coalesce.

Ejemplos

julia> f(x) = (println("f($x)"); missing);

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` sigue siendo missing")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` sigue siendo missing")
f(2)
f(3)
ERROR: `b` sigue siendo missing
[...]

ismissing(x)

Indica si x es missing.

Véase también: skipmissing, isnothing, isnan.

skipmissing(itr)

Devuelve un iterador sobre los elementos en itr omitiendo los valores missing. El objeto devuelto se puede indexar utilizando los índices de itr si este último es indexable. Los índices correspondientes a valores faltantes no son válidos: son omitidos por keys y eachindex, y se lanza una MissingException al intentar usarlos.

Utiliza collect para obtener un Array que contenga los valores no missing en itr. Ten en cuenta que incluso si itr es un array multidimensional, el resultado siempre será un Vector ya que no es posible eliminar los valores faltantes mientras se preservan las dimensiones de la entrada.

Consulta también coalesce, ismissing, something.

Ejemplos

julia> x = skipmissing([1, missing, 2])
skipmissing(Union{Missing, Int64}[1, missing, 2])

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
ERROR: MissingException: el valor en el índice (2,) está faltando
[...]

julia> argmax(x)
3

julia> collect(keys(x))
Vector{Int64} de 2 elementos:
 1
 3

julia> collect(skipmissing([1, missing, 2]))
Vector{Int64} de 2 elementos:
 1
 2

julia> collect(skipmissing([1 missing; 2 missing]))
Vector{Int64} de 2 elementos:
 1
 2

nonmissingtype(T::Type)

Si T es una unión de tipos que contiene Missing, devuelve un nuevo tipo con Missing eliminado.

Ejemplos

julia> nonmissingtype(Union{Int64,Missing})
Int64

julia> nonmissingtype(Any)
Any

run(command, args...; wait::Bool = true)

Ejecuta un objeto de comando, construido con comillas invertidas (ver la sección de Ejecutar Programas Externos en el manual). Lanza un error si algo sale mal, incluyendo si el proceso sale con un estado distinto de cero (cuando wait es verdadero).

Los args... te permiten pasar descriptores de archivo al comando, y están ordenados como descriptores de archivo unix regulares (por ejemplo stdin, stdout, stderr, FD(3), FD(4)...).

Si wait es falso, el proceso se ejecuta de manera asíncrona. Puedes esperar por él más tarde y verificar su estado de salida llamando a success en el objeto de proceso devuelto.

Cuando wait es falso, los flujos de I/O del proceso se dirigen a devnull. Cuando wait es verdadero, los flujos de I/O se comparten con el proceso padre. Usa pipeline para controlar la redirección de I/O.

devnull

Utilizado en una redirección de flujo para descartar todos los datos escritos en él. Esencialmente equivalente a /dev/null en Unix o NUL en Windows. Uso:

run(pipeline(`cat test.txt`, devnull))

success(command)

Ejecuta un objeto de comando, construido con comillas invertidas (ver la sección Ejecutando Programas Externos en el manual), y dice si fue exitoso (salió con un código de 0). Se lanza una excepción si el proceso no se puede iniciar.

process_running(p::Process)

Determina si un proceso se está ejecutando actualmente.

process_exited(p::Process)

Determina si un proceso ha salido.

kill(p::Process, signum=Base.SIGTERM)

Envía una señal a un proceso. El valor predeterminado es terminar el proceso. Devuelve con éxito si el proceso ya ha salido, pero lanza un error si la terminación del proceso falló por otras razones (por ejemplo, permisos insuficientes).

Sys.set_process_title(title::AbstractString)

Establece el título del proceso. No tiene efecto en algunos sistemas operativos.

Sys.get_process_title()

Obtiene el título del proceso. En algunos sistemas, siempre devolverá una cadena vacía.

ignorestatus(command)

Marca un objeto de comando para que su ejecución no genere un error si el código de resultado es diferente de cero.

detach(command)

Marca un objeto de comando para que se ejecute en un nuevo grupo de procesos, permitiendo que sobreviva al proceso de julia y que no se le pasen interrupciones de Ctrl-C.

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)
Cmd(exec::Vector{String})

Construye un nuevo objeto Cmd, que representa un programa externo y argumentos, a partir de cmd, mientras cambia la configuración de los argumentos opcionales:

• ignorestatus::Bool: Si es true (por defecto es false), entonces el Cmd no lanzará un error si el código de retorno es diferente de cero.
• detach::Bool: Si es true (por defecto es false), entonces el Cmd se ejecutará en un nuevo grupo de procesos, permitiendo que sobreviva al proceso julia y que no se le pase Ctrl-C.
• windows_verbatim::Bool: Si es true (por defecto es false), entonces en Windows el Cmd enviará una cadena de línea de comandos al proceso sin comillas ni escape de argumentos, incluso argumentos que contengan espacios. (En Windows, los argumentos se envían a un programa como una única cadena de "línea de comandos", y los programas son responsables de analizarla en argumentos. Por defecto, los argumentos vacíos y los argumentos con espacios o tabulaciones se citan con comillas dobles " en la línea de comandos, y \ o " son precedidos por barras invertidas. windows_verbatim=true es útil para lanzar programas que analizan su línea de comandos de maneras no estándar.) No tiene efecto en sistemas que no son Windows.
• windows_hide::Bool: Si es true (por defecto es false), entonces en Windows no se muestra una nueva ventana de consola cuando se ejecuta el Cmd. Esto no tiene efecto si ya hay una consola abierta o en sistemas que no son Windows.
• env: Establece las variables de entorno a utilizar al ejecutar el Cmd. env es un diccionario que mapea cadenas a cadenas, un array de cadenas de la forma "var=val", un array o tupla de pares "var"=>val. Para modificar (en lugar de reemplazar) el entorno existente, inicializa env con copy(ENV) y luego establece env["var"]=val según sea necesario. Para agregar a un bloque de entorno dentro de un objeto Cmd sin reemplazar todos los elementos, usa addenv() que devolverá un objeto Cmd con el entorno actualizado.
• dir::AbstractString: Especifica un directorio de trabajo para el comando (en lugar del directorio actual).

Para cualquier palabra clave que no esté especificada, se utilizan las configuraciones actuales de cmd.

Ten en cuenta que el constructor Cmd(exec) no crea una copia de exec. Cualquier cambio posterior en exec se reflejará en el objeto Cmd.

La forma más común de construir un objeto Cmd es con literales de comando (comillas invertidas), por ejemplo:

`ls -l`

Esto se puede pasar al constructor Cmd para modificar su configuración, por ejemplo:

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

setenv(command::Cmd, env; dir)

Establece las variables de entorno que se utilizarán al ejecutar el command dado. env es un diccionario que mapea cadenas a cadenas, un arreglo de cadenas de la forma "var=val", o cero o más argumentos de pares "var"=>val. Para modificar (en lugar de reemplazar) el entorno existente, crea env a través de copy(ENV) y luego establece env["var"]=val según sea necesario, o usa addenv.

El argumento clave dir se puede usar para especificar un directorio de trabajo para el comando. dir por defecto es el dir actualmente establecido para command (que es el directorio de trabajo actual si no se especifica ya).

Consulta también Cmd, addenv, ENV, pwd.

addenv(command::Cmd, env...; inherit::Bool = true)

Fusiona nuevos mapeos de entorno en el objeto Cmd dado, devolviendo un nuevo objeto Cmd. Las claves duplicadas son reemplazadas. Si command no contiene ningún valor de entorno establecido ya, hereda el entorno actual en el momento de la llamada a addenv() si inherit es true. Las claves con valor nothing se eliminan del entorno.

Véase también Cmd, setenv, ENV.

withenv(f, kv::Pair...)

Ejecuta f en un entorno que se modifica temporalmente (no se reemplaza como en setenv) por cero o más argumentos "var"=>val kv. withenv se utiliza generalmente a través de la sintaxis withenv(kv...) do ... end. Un valor de nothing se puede usar para desactivar temporalmente una variable de entorno (si está configurada). Cuando withenv retorna, el entorno original ha sido restaurado.

setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

Establece la afinidad de CPU del command mediante una lista de IDs de CPU (basados en 1) cpus. Pasar cpus = nothing significa desactivar la afinidad de CPU si el original_command tiene alguna.

Esta función es compatible solo en Linux y Windows. No es compatible en macOS porque libuv no admite la configuración de afinidad.

Ejemplos

En Linux, se puede usar el programa de línea de comandos taskset para ver cómo funciona setcpuaffinity.

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

Tenga en cuenta que el valor de la máscara 13 refleja que los primeros, segundos y quintos bits (contando desde la posición menos significativa) están activados:

julia> 0b010011
0x13

pipeline(from, to, ...)

Crea un pipeline desde una fuente de datos hasta un destino. La fuente y el destino pueden ser comandos, flujos de E/S, cadenas o resultados de otras llamadas a pipeline. Al menos un argumento debe ser un comando. Las cadenas se refieren a nombres de archivos. Cuando se llama con más de dos argumentos, se encadenan de izquierda a derecha. Por ejemplo, pipeline(a,b,c) es equivalente a pipeline(pipeline(a,b),c). Esto proporciona una forma más concisa de especificar pipelines de múltiples etapas.

Ejemplos:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

pipeline(command; stdin, stdout, stderr, append=false)

Redirigir I/O hacia o desde el command dado. Los argumentos de palabra clave especifican cuáles de los flujos del comando deben ser redirigidos. append controla si la salida del archivo se agrega al archivo. Esta es una versión más general de la función pipeline de 2 argumentos. pipeline(from, to) es equivalente a pipeline(from, stdout=to) cuando from es un comando, y a pipeline(to, stdin=from) cuando from es otro tipo de fuente de datos.

Ejemplos:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

gethostname() -> String

Obtiene el nombre del host de la máquina local.

getpid() -> Int32

Obtiene el ID del proceso de Julia.

getpid(process) -> Int32

Obtiene el ID del proceso hijo, si aún existe.

time() -> Float64

Obtiene el tiempo del sistema en segundos desde la época, con una resolución bastante alta (típicamente, microsegundos).

time_ns() -> UInt64

Obtiene el tiempo en nanosegundos. El tiempo correspondiente a 0 es indefinido y se reinicia cada 5.8 años.

@time expr
@time "descripción" expr

Una macro para ejecutar una expresión, imprimiendo el tiempo que tomó ejecutarla, el número de asignaciones y el número total de bytes que su ejecución causó que se asignaran, antes de devolver el valor de la expresión. Cualquier tiempo gastado en recolección de basura (gc), compilando nuevo código, o recompilando código invalidado se muestra como un porcentaje. Cualquier conflicto de bloqueo donde un ReentrantLock tuvo que esperar se muestra como un conteo.

Opcionalmente, proporciona una cadena de descripción para imprimir antes del informe de tiempo.

En algunos casos, el sistema mirará dentro de la expresión @time y compilará parte del código llamado antes de que comience la ejecución de la expresión de nivel superior. Cuando eso sucede, parte del tiempo de compilación no se contará. Para incluir este tiempo, puedes ejecutar @time @eval ....

Consulta también @showtime, @timev, @timed, @elapsed, @allocated, y @allocations.

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 segundos (2.19 M asignaciones: 116.555 MiB, 3.75% tiempo gc, 99.94% tiempo de compilación)

julia> @time x * x;
  0.000009 segundos (1 asignación: 896 bytes)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 segundos (8 asignaciones: 336 bytes)
2

julia> @time "Un sueño de un segundo" sleep(1)
Un sueño de un segundo: 1.005750 segundos (5 asignaciones: 144 bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 segundos (5 asignaciones: 144 bytes)
2: 1.001263 segundos (5 asignaciones: 144 bytes)
3: 1.003676 segundos (5 asignaciones: 144 bytes)

@showtime expr

Como @time pero también imprime la expresión que se está evaluando como referencia.

Véase también @time.

julia> @showtime sleep(1)
sleep(1): 1.002164 segundos (4 asignaciones: 128 bytes)

@timev expr
@timev "description" expr

Esta es una versión detallada de la macro @time. Primero imprime la misma información que @time, luego cualquier contador de asignación de memoria no cero, y luego devuelve el valor de la expresión.

Opcionalmente, proporciona una cadena de descripción para imprimir antes del informe de tiempo.

Véase también @time, @timed, @elapsed, @allocated, y @allocations.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 seconds (2.20 M allocations: 116.632 MiB, 4.23% gc time, 99.94% compilation time)
elapsed time (ns): 546769547
gc time (ns):      23115606
bytes allocated:   122297811
pool allocs:       2197930
non-pool GC allocs:1327
malloc() calls:    36
realloc() calls:   5
GC pauses:         3

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1

@timed

Una macro para ejecutar una expresión y devolver el valor de la expresión, el tiempo transcurrido en segundos, el total de bytes asignados, el tiempo de recolección de basura, un objeto con varios contadores de asignación de memoria, el tiempo de compilación en segundos y el tiempo de recompilación en segundos. Cualquier conflicto de bloqueo donde un ReentrantLock tuvo que esperar se muestra como un conteo.

En algunos casos, el sistema mirará dentro de la expresión @timed y compilará parte del código llamado antes de que comience la ejecución de la expresión de nivel superior. Cuando eso sucede, parte del tiempo de compilación no se contará. Para incluir este tiempo, puedes ejecutar @timed @eval ....

Ver también @time, @timev, @elapsed, @allocated, @allocations y @lock_conflicts.

julia> stats = @timed rand(10^6);

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

julia> propertynames(stats.gcstats)
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> stats.gcstats.total_time
5576500

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0

@elapsed

Una macro para evaluar una expresión, descartando el valor resultante, en su lugar devolviendo el número de segundos que tomó ejecutarse como un número de punto flotante.

En algunos casos, el sistema mirará dentro de la expresión @elapsed y compilará parte del código llamado antes de que comience la ejecución de la expresión de nivel superior. Cuando eso sucede, parte del tiempo de compilación no se contará. Para incluir este tiempo, puedes ejecutar @elapsed @eval ....

Consulta también @time, @timev, @timed, @allocated, y @allocations.

julia> @elapsed sleep(0.3)
0.301391426

@allocated

Una macro para evaluar una expresión, descartando el valor resultante, en su lugar devolviendo el número total de bytes asignados durante la evaluación de la expresión.

Véase también @allocations, @time, @timev, @timed, y @elapsed.

julia> @allocated rand(10^6)
8000080

@allocations

Una macro para evaluar una expresión, descartar el valor resultante y, en su lugar, devolver el número total de asignaciones durante la evaluación de la expresión.

Véase también @allocated, @time, @timev, @timed y @elapsed.

julia> @allocations rand(10^6)
2

@lock_conflicts

Una macro para evaluar una expresión, descartar el valor resultante y, en su lugar, devolver el número total de conflictos de bloqueo durante la evaluación, donde un intento de bloqueo en un ReentrantLock resultó en una espera porque el bloqueo ya estaba en uso.

Véase también @time, @timev y @timed.

julia> @lock_conflicts begin
    l = ReentrantLock()
    Threads.@threads for i in 1:Threads.nthreads()
        lock(l) do
        sleep(1)
        end
    end
end
5

EnvDict() -> EnvDict

Un singleton de este tipo proporciona una interfaz de tabla hash a las variables de entorno.

ENV

Referencia al singleton EnvDict, que proporciona una interfaz de diccionario a las variables de entorno del sistema.

(En Windows, las variables de entorno del sistema no son sensibles a mayúsculas y minúsculas, y ENV convierte correspondientemente todas las claves a mayúsculas para su visualización, iteración y copia. El código portátil no debe depender de la capacidad de distinguir variables por caso, y debe tener cuidado de que establecer una variable aparentemente en minúsculas puede resultar en una clave ENV en mayúsculas.)

Ejemplos

julia> ENV
Base.EnvDict con "50" entradas:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "nombredeusuario"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

Ver también: withenv, addenv.

Sys.STDLIB::String

Una cadena que contiene la ruta completa al directorio que contiene los paquetes stdlib.

Sys.isunix([os])

Predicado para probar si el sistema operativo proporciona una interfaz similar a Unix. Consulta la documentación en Handling Operating System Variation.

Sys.isapple([os])

Predicado para probar si el sistema operativo es un derivado de Apple Macintosh OS X o Darwin. Consulta la documentación en Handling Operating System Variation.

Sys.islinux([os])

Predicado para probar si el sistema operativo es un derivado de Linux. Consulta la documentación en Handling Operating System Variation.

Sys.isbsd([os])

Predicado para probar si el sistema operativo es un derivado de BSD. Consulta la documentación en Handling Operating System Variation.

Sys.isfreebsd([os])

Predicado para probar si el sistema operativo es un derivado de FreeBSD. Consulta la documentación en Handling Operating System Variation.

Sys.isopenbsd([os])

Predicado para probar si el sistema operativo es un derivado de OpenBSD. Consulta la documentación en Handling Operating System Variation.

Sys.isnetbsd([os])

Predicado para probar si el sistema operativo es un derivado de NetBSD. Consulta la documentación en Handling Operating System Variation.

Sys.isdragonfly([os])

Predicado para probar si el sistema operativo es un derivado de DragonFly BSD. Consulta la documentación en Handling Operating System Variation.

Sys.iswindows([os])

Predicado para probar si el sistema operativo es un derivado de Microsoft Windows NT. Consulta la documentación en Handling Operating System Variation.

Sys.windows_version()

Devuelve el número de versión del núcleo de Windows NT como un VersionNumber, es decir, v"mayor.menor.construcción", o v"0.0.0" si esto no se está ejecutando en Windows.

Sys.free_memory()

Obtiene la memoria total libre en RAM en bytes.

Sys.total_memory()

Obtiene la memoria total en RAM (incluyendo la que se está utilizando actualmente) en bytes. Esta cantidad puede estar restringida, por ejemplo, por los grupos de control de Linux. Para la cantidad sin restricciones, consulte Sys.total_physical_memory().

Sys.free_physical_memory()

Obtiene la memoria libre del sistema en bytes. La cantidad total puede no estar disponible para el proceso actual; utiliza Sys.free_memory() para la cantidad realmente disponible.

Sys.total_physical_memory()

Obtiene la memoria total en RAM (incluyendo la que está actualmente en uso) en bytes. La cantidad total puede no estar disponible para el proceso actual; consulta Sys.total_memory().

Sys.uptime()

Obtiene el tiempo de actividad actual del sistema en segundos.

Sys.isjsvm([os])

Predicado para probar si Julia se está ejecutando en una máquina virtual de JavaScript (JSVM), incluyendo, por ejemplo, una incrustación de JavaScript de WebAssembly en un navegador web.

Sys.loadavg()

Obtiene el promedio de carga. Ver: https://en.wikipedia.org/wiki/Load_(computing).

isexecutable(path::String)

Devuelve true si el path dado tiene permisos de ejecución.

Véase también ispath, isreadable, iswritable.

isreadable(path::String)

Devuelve true si los permisos de acceso para la ruta dada permiten la lectura por parte del usuario actual.

Véase también ispath, isexecutable, iswritable. ```

isreadable(io) -> Bool

Devuelve false si el objeto IO especificado no es legible.

Ejemplos

julia> open("myfile.txt", "w") do io
           print(io, "¡Hola mundo!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

iswritable(path::String)

Devuelve true si los permisos de acceso para la ruta dada permiten la escritura por parte del usuario actual.

Véase también ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Devuelve false si el objeto IO especificado no es escribible.

Ejemplos

julia> open("myfile.txt", "w") do io
           print(io, "¡Hola mundo!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

Sys.username() -> String

Devuelve el nombre de usuario del usuario actual. Si no se puede determinar el nombre de usuario o está vacío, esta función lanza un error.

Para recuperar un nombre de usuario que se puede sobrescribir a través de una variable de entorno, por ejemplo, USER, considera usar

user = get(Sys.username, ENV, "USER")

Consulta también homedir.

@static

Evalúa parcialmente una expresión en el tiempo de análisis.

Por ejemplo, @static Sys.iswindows() ? foo : bar evaluará Sys.iswindows() e insertará ya sea foo o bar en la expresión. Esto es útil en casos donde un constructo sería inválido en otras plataformas, como un ccall a una función inexistente. @static if Sys.isapple() foo end y @static foo <&&,||> bar también son sintaxis válidas.

VersionNumber

Tipo de número de versión que sigue las especificaciones de versionado semántico (semver), compuesto por valores numéricos mayor, menor y de parche, seguidos de anotaciones alfanuméricas de pre-lanzamiento y construcción.

Los objetos VersionNumber se pueden comparar con todos los operadores de comparación estándar (==, <, <=, etc.), con el resultado siguiendo las reglas de semver.

VersionNumber tiene los siguientes campos públicos:

• v.major::Integer
• v.minor::Integer
• v.patch::Integer
• v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}
• v.build::Tuple{Vararg{Union{Integer, AbstractString}}}

Véase también @v_str para construir de manera eficiente objetos VersionNumber a partir de cadenas literales en formato semver, VERSION para el VersionNumber de Julia en sí, y Literales de Números de Versión en el manual.

Ejemplos

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

julia> b = VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"

julia> b >= v"2.0.1"
false

@v_str

Macro de cadena utilizado para analizar una cadena a un VersionNumber.

Ejemplos

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

error(message::AbstractString)

Lanza un ErrorException con el mensaje dado.

error(msg...)

Lanza un ErrorException con un mensaje construido por string(msg...).

throw(e)

Lanza un objeto como una excepción.

Ver también: rethrow, error.

rethrow()

Vuelve a lanzar la excepción actual desde dentro de un bloque catch. La excepción relanzada continuará propagándose como si no hubiera sido capturada.

backtrace()

Obtiene un objeto de backtrace para el punto actual del programa.

catch_backtrace()

Obtiene el backtrace de la excepción actual, para usar dentro de bloques catch.

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

Obtiene la pila de excepciones que se están manejando actualmente. Para bloques de captura anidados, puede haber más de una excepción actual, en cuyo caso la excepción lanzada más recientemente está al final de la pila. La pila se devuelve como un ExceptionStack, que es un AbstractVector de tuplas nombradas (exception,backtrace). Si backtrace es falso, la traza de la pila en cada par se establecerá en nothing.

Pasar explícitamente task devolverá la pila de excepciones actual en una tarea arbitraria. Esto es útil para inspeccionar tareas que han fallado debido a excepciones no capturadas.

@assert cond [texto]

Lanza un AssertionError si cond es false. Esta es la sintaxis preferida para escribir afirmaciones, que son condiciones que se asumen como verdaderas, pero que el usuario podría decidir verificar de todos modos, como una ayuda para la depuración si fallan. El mensaje opcional texto se muestra al fallar la afirmación.

Ejemplos

julia> @assert iseven(3) "¡3 es un número impar!"
ERROR: AssertionError: 3 es un número impar!

julia> @assert isodd(3) "¿Qué son los números pares?"

Experimental.register_error_hint(handler, exceptiontype)

Registra una función de "sugerencia" handler(io, exception) que puede sugerir formas potenciales para que los usuarios eviten errores. handler debe examinar exception para ver si se cumplen las condiciones apropiadas para una sugerencia y, de ser así, generar salida a io. Los paquetes deben llamar a register_error_hint desde dentro de su función __init__.

Para tipos de excepciones específicos, se requiere que handler acepte argumentos adicionales:

• MethodError: proporcionar handler(io, exc::MethodError, argtypes, kwargs), que divide los argumentos combinados en argumentos posicionales y de palabra clave.

Al emitir una sugerencia, la salida debe comenzar típicamente con \n.

Si defines tipos de excepciones personalizados, tu método showerror puede soportar sugerencias llamando a Experimental.show_error_hints.

Ejemplos

julia> module Hinter

       only_int(x::Int)      = 1
       any_number(x::Number) = 2

       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # El color no es necesario, esto es solo para mostrar que es posible.
                    print(io, "\n¿Quisiste llamar a ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

Entonces, si llamas a Hinter.only_int con algo que no es un Int (activando así un MethodError), emite la sugerencia:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
La función `only_int` existe, pero no se define ningún método para esta combinación de tipos de argumento.
¿Quisiste llamar a `any_number`?
Los candidatos más cercanos son:
    ...

Experimental.show_error_hints(io, ex, args...)

Invoca todos los controladores de Experimental.register_error_hint para el tipo de excepción particular typeof(ex). args debe contener cualquier otro argumento esperado por el controlador para ese tipo.

ArgumentError(msg)

Los argumentos pasados a una función son inválidos. msg es un mensaje de error descriptivo.

AssertionError([msg])

La condición afirmada no se evaluó como true. El argumento opcional msg es una cadena de error descriptiva.

Ejemplos

julia> @assert false "esto no es verdad"
ERROR: AssertionError: esto no es verdad

AssertionError generalmente se lanza desde @assert. ```

BoundsError([a],[i])

Una operación de indexación en un arreglo, a, intentó acceder a un elemento fuera de los límites en el índice i.

Ejemplos

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: intento de acceder a un Vector{Float64} de 7 elementos en el índice [8]


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERROR: BoundsError: intento de acceder a una Matriz{Float64} de 2×3 en el índice [2, 4]


julia> B[9]
ERROR: BoundsError: intento de acceder a una Matriz{Float64} de 2×3 en el índice [9]

CompositeException

Envuelve un Vector de excepciones lanzadas por una Task (por ejemplo, generadas por un trabajador remoto a través de un canal o una escritura de E/S local que se ejecuta de forma asíncrona o un trabajador remoto bajo pmap) con información sobre la serie de excepciones. Por ejemplo, si un grupo de trabajadores está ejecutando varias tareas y múltiples trabajadores fallan, el CompositeException resultante contendrá un "paquete" de información de cada trabajador que indica dónde y por qué ocurrieron las excepciones.

DimensionMismatch([msg])

Los objetos llamados no tienen una dimensionalidad coincidente. El argumento opcional msg es una cadena de error descriptiva.

DivideError()

Se intentó una división entera con un valor de denominador de 0.

Ejemplos

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: error de división entera
Stacktrace:
[...]

DomainError(val)
DomainError(val, msg)

El argumento val a una función o constructor está fuera del dominio válido.

Ejemplos

julia> sqrt(-1)
ERROR: DomainError con -1.0:
sqrt fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta sqrt(Complex(x)).
Stacktrace:
[...]

EOFError()

No hay más datos disponibles para leer de un archivo o flujo.

ErrorException(msg)

Tipo de error genérico. El mensaje de error, en el campo .msg, puede proporcionar detalles más específicos.

Ejemplos

julia> ex = ErrorException("He hecho algo malo");

julia> ex.msg
"He hecho algo malo"

InexactError(nombre::Symbol, T, val)

No se puede convertir exactamente val al tipo T en un método de la función nombre.

Ejemplos

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]

InterruptException()

El proceso fue detenido por una interrupción del terminal (CTRL+C).

Tenga en cuenta que, en un script de Julia iniciado sin la opción -i (interactiva), InterruptException no se lanza por defecto. Llamar a Base.exit_on_sigint(false) en el script puede recuperar el comportamiento del REPL. Alternativamente, un script de Julia se puede iniciar con

julia -e "include(popfirst!(ARGS))" script.jl

para permitir que InterruptException se lance por CTRL+C durante la ejecución.

KeyError(key)

Una operación de indexación en un AbstractDict (Dict) o un objeto tipo Set intentó acceder o eliminar un elemento que no existe.

LoadError(file::AbstractString, line::Int, error)

Ocurrió un error mientras se include, require o using un archivo. Los detalles del error deberían estar disponibles en el campo .error.

MethodError(f, args)

No existe un método con la firma de tipo requerida en la función genérica dada. Alternativamente, no hay un método más específico único.

MissingException(msg)

Excepción lanzada cuando se encuentra un valor missing en una situación donde no es compatible. El mensaje de error, en el campo msg, puede proporcionar detalles más específicos.

OutOfMemoryError()

Una operación asignó demasiada memoria para que el sistema o el recolector de basura pudieran manejarla adecuadamente.

ReadOnlyMemoryError()

Una operación intentó escribir en una memoria que es de solo lectura.

OverflowError(msg)

El resultado de una expresión es demasiado grande para el tipo especificado y causará un desbordamiento.

ProcessFailedException

Indica un estado de salida problemático de un proceso. Al ejecutar comandos o tuberías, esto se lanza para indicar que se devolvió un código de salida distinto de cero (es decir, que el proceso invocado falló).

TaskFailedException

Esta excepción es lanzada por una llamada a wait(t) cuando la tarea t falla. TaskFailedException envuelve la tarea fallida t.

StackOverflowError()

La llamada a la función creció más allá del tamaño de la pila de llamadas. Esto suele suceder cuando una llamada se recursiona infinitamente.

SystemError(prefix::AbstractString, [errno::Int32])

Una llamada al sistema falló con un código de error (en la variable global errno).

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Una falla de afirmación de tipo, o llamar a una función intrínseca con un tipo de argumento incorrecto.

UndefKeywordError(var::Symbol)

El argumento de palabra clave requerido var no fue asignado en una llamada a función.

Ejemplos

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument `my_arg` not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1

UndefRefError()

El ítem o campo no está definido para el objeto dado.

Ejemplos

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: acceso a referencia indefinida
Stacktrace:
[...]

UndefVarError(var::Symbol, [scope])

Un símbolo en el ámbito actual no está definido.

Ejemplos

julia> a
ERROR: UndefVarError: `a` no definido en `Main`

julia> a = 1;

julia> a
1

StringIndexError(str, i)

Se produjo un error al intentar acceder a str en el índice i que no es válido.

InitError(mod::Symbol, error)

Ocurrió un error al ejecutar la función __init__ de un módulo. El error real lanzado está disponible en el campo .error.

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

Devuelve una función anónima que llama a la función f. Si se produce una excepción, f se vuelve a llamar repetidamente, cada vez que check devuelve true, después de esperar el número de segundos especificado en delays. check debe ingresar el estado actual de delays y la Exception.