Interactive Utilities

apropos([io::IO=stdout], pattern::Union{AbstractString,Regex})

Busca las cadenas de documentación disponibles para las entradas que contienen pattern.

Cuando pattern es una cadena, se ignora el caso. Los resultados se imprimen en io.

apropos se puede llamar desde el modo de ayuda en el REPL envolviendo la consulta entre comillas dobles:

help?> "pattern"

varinfo(m::Module=Main, pattern::Regex=r""; all=false, imported=false, recursive=false, sortby::Symbol=:name, minsize::Int=0)

Devuelve una tabla en markdown que proporciona información sobre variables globales públicas en un módulo, restringidas opcionalmente a aquellas que coinciden con pattern.

La estimación del consumo de memoria es un límite inferior aproximado del tamaño de la estructura interna del objeto.

• all : también lista objetos no públicos definidos en el módulo, objetos obsoletos y objetos generados por el compilador.
• imported : también lista objetos importados explícitamente de otros módulos.
• recursive : incluye recursivamente objetos en sub-módulos, observando la misma configuración en cada uno.
• sortby : la columna por la que ordenar los resultados. Las opciones son :name (predeterminado), :size y :summary.
• minsize : solo incluye objetos con un tamaño de al menos minsize bytes. Por defecto es 0.

La salida de varinfo está destinada solo a fines de visualización. Véase también names para obtener un array de símbolos definidos en un módulo, que es adecuado para manipulaciones más generales.

versioninfo(io::IO=stdout; verbose::Bool=false)

Imprime información sobre la versión de Julia en uso. La salida se controla con argumentos de palabra clave booleanos:

• verbose: imprime toda la información adicional

Véase también: VERSION.

methodswith(typ[, módulo o función]; supertypes::Bool=false])

Devuelve un array de métodos con un argumento de tipo typ.

El segundo argumento opcional restringe la búsqueda a un módulo o función particular (el valor predeterminado son todos los módulos de nivel superior).

Si la palabra clave supertypes es true, también devuelve argumentos con un tipo padre de typ, excluyendo el tipo Any.

Véase también: methods. ```

subtipos(T::DataType)

Devuelve una lista de subtipos inmediatos del tipo de dato T. Ten en cuenta que se incluyen todos los subtipos actualmente cargados, incluidos aquellos que no son visibles en el módulo actual.

Consulta también supertype, supertypes, methodswith.

Ejemplos

julia> subtipos(Integer)
3-element Vector{Any}:
 Bool
 Signed
 Unsigned

supertypes(T::Type)

Devuelve una tupla (T, ..., Any) de T y todos sus supertipos, según lo determinado por llamadas sucesivas a la función supertype, listados en orden de <: y terminados por Any.

Véase también subtypes.

Ejemplos

julia> supertypes(Int)
(Int64, Signed, Integer, Real, Number, Any)

edit(path::AbstractString, line::Integer=0, column::Integer=0)

Edita un archivo o directorio proporcionando opcionalmente un número de línea para editar el archivo. Regresa al prompt de julia cuando salgas del editor. El editor se puede cambiar configurando JULIA_EDITOR, VISUAL o EDITOR como una variable de entorno.

Consulta también InteractiveUtils.define_editor.

edit(function, [types])
edit(module)

Edita la definición de una función, especificando opcionalmente una tupla de tipos para indicar qué método editar. Para los módulos, abre el archivo fuente principal. El módulo debe ser cargado con using o import primero.

Para asegurarte de que el archivo se pueda abrir en la línea dada, es posible que necesites llamar a InteractiveUtils.define_editor primero.

@edit

Evalúa los argumentos de la llamada a la función o macro, determina sus tipos y llama a la función edit en la expresión resultante.

Véase también: @less, @which.

define_editor(fn, pattern; wait=false)

Define un nuevo editor que coincida con pattern que se puede usar para abrir un archivo (posiblemente en un número de línea dado) usando fn.

El argumento fn es una función que determina cómo abrir un archivo con el editor dado. Debe tomar cuatro argumentos, de la siguiente manera:

• cmd - un objeto de comando base para el editor
• path - la ruta al archivo fuente que se va a abrir
• line - el número de línea para abrir el editor
• column - el número de columna para abrir el editor

Los editores que no pueden abrirse en una línea específica con un comando o en una columna específica pueden ignorar el argumento line y/o column. La devolución de llamada fn debe devolver un objeto Cmd apropiado para abrir un archivo o nothing para indicar que no pueden editar este archivo. Usa nothing para indicar que este editor no es apropiado para el entorno actual y se debe intentar con otro editor. Es posible agregar más ganchos de edición generales que no necesiten generar comandos externos al empujar una devolución de llamada directamente al vector EDITOR_CALLBACKS.

El argumento pattern es una cadena, expresión regular o un arreglo de cadenas y expresiones regulares. Para que se llame a fn, uno de los patrones debe coincidir con el valor de EDITOR, VISUAL o JULIA_EDITOR. Para cadenas, la cadena debe ser igual al basename de la primera palabra del comando del editor, con su extensión, si la hay, eliminada. Por ejemplo, "vi" no coincide con "vim -g" pero coincide con "/usr/bin/vi -m"; también coincide con vi.exe. Si pattern es una regex, se compara con todo el comando del editor como una cadena escapada por el shell. Un patrón de arreglo coincide si cualquiera de sus elementos coincide. Si varios editores coinciden, se utiliza el que se agregó más recientemente.

Por defecto, julia no espera a que el editor se cierre, ejecutándolo en segundo plano. Sin embargo, si el editor es basado en terminal, probablemente querrás establecer wait=true y julia esperará a que el editor se cierre antes de reanudar.

Si una de las variables de entorno del editor está configurada, pero ninguna entrada de editor coincide con ella, se invoca la entrada de editor predeterminada:

(cmd, path, line, column) -> `$cmd $path`

Ten en cuenta que muchos editores ya están definidos. Todos los siguientes comandos deberían funcionar ya:

• emacs
• emacsclient
• vim
• nvim
• nano
• micro
• kak
• helix
• textmate
• mate
• kate
• subl
• atom
• notepad++
• Visual Studio Code
• open
• pycharm
• bbedit

Ejemplos

Lo siguiente define el uso de emacs basado en terminal:

define_editor(
    r"\bemacs\b.*\s(-nw|--no-window-system)\b", wait=true) do cmd, path, line
    `$cmd +$line $path`
end

less(file::AbstractString, [line::Integer])

Muestra un archivo utilizando el paginador predeterminado, proporcionando opcionalmente un número de línea de inicio. Regresa al prompt de julia cuando sales del paginador.

less(function, [types])

Muestra la definición de una función utilizando el paginador predeterminado, especificando opcionalmente una tupla de tipos para indicar qué método ver.

@less

Evalúa los argumentos de la llamada a la función o macro, determina sus tipos y llama a la función less en la expresión resultante.

Véase también: @edit, @which, @code_lowered.

@which

Aplicado a una llamada de función o macro, evalúa los argumentos de la llamada especificada y devuelve el objeto Method para el método que se llamaría para esos argumentos. Aplicado a una variable, devuelve el módulo en el que se vinculó la variable. Llama a la función which.

Véase también: @less, @edit.

@functionloc

Aplicado a una llamada de función o macro, evalúa los argumentos de la llamada especificada y devuelve una tupla (nombre_archivo, línea) que indica la ubicación del método que se llamaría para esos argumentos. Llama a la función functionloc.

@code_lowered

Evalúa los argumentos de la llamada a la función o macro, determina sus tipos y llama a code_lowered en la expresión resultante.

Véase también: code_lowered, @code_warntype, @code_typed, @code_llvm, @code_native.

@code_typed

Evalúa los argumentos de la llamada a la función o macro, determina sus tipos y llama a code_typed en la expresión resultante. Usa el argumento opcional optimize con

@code_typed optimize=true foo(x)

para controlar si se aplican optimizaciones adicionales, como la inlining.

Ver también: code_typed, @code_warntype, @code_lowered, @code_llvm, @code_native.

code_warntype([io::IO], f, types; debuginfo=:default)

Imprime ASTs bajados e inferidos por tipo para los métodos que coinciden con la función genérica dada y la firma de tipo a io, que por defecto es stdout. Los ASTs están anotados de tal manera que los tipos "no hoja" que pueden ser problemáticos para el rendimiento se enfatizan (si hay color disponible, se muestran en rojo). Esto sirve como una advertencia de posible inestabilidad de tipo.

No todos los tipos no hoja son particularmente problemáticos para el rendimiento, y las características de rendimiento de un tipo particular son un detalle de implementación del compilador. code_warntype errará del lado de colorear los tipos de rojo si podrían ser una preocupación de rendimiento, por lo que algunos tipos pueden estar coloreados de rojo incluso si no impactan el rendimiento. Pequeñas uniones de tipos concretos generalmente no son una preocupación, por lo que se destacan en amarillo.

El argumento clave debuginfo puede ser uno de :source o :none (por defecto), para especificar la verbosidad de los comentarios de código.

Consulta la sección @code_warntype en la página de Consejos de Rendimiento del manual para más información.

Consulta también: @code_warntype, code_typed, code_lowered, code_llvm, code_native.

@code_warntype

Evalúa los argumentos de la llamada a la función o macro, determina sus tipos y llama a code_warntype en la expresión resultante.

Véase también: code_warntype, @code_typed, @code_lowered, @code_llvm, @code_native.

code_llvm([io=stdout,], f, types; raw=false, dump_module=false, optimize=true, debuginfo=:default)

Imprime los códigos de bits LLVM generados para ejecutar el método que coincide con la función genérica y la firma de tipo dadas en io.

Si la palabra clave optimize no está establecida, el código se mostrará antes de las optimizaciones de LLVM. Todos los metadatos y las llamadas a dbg.* se eliminan del código de bits impreso. Para el IR completo, establece la palabra clave raw en true. Para volcar todo el módulo que encapsula la función (con declaraciones), establece la palabra clave dump_module en true. El argumento de palabra clave debuginfo puede ser uno de source (predeterminado) o none, para especificar la verbosidad de los comentarios del código.

Ver también: @code_llvm, code_warntype, code_typed, code_lowered, code_native.

@code_llvm

Evalúa los argumentos de la función o llamada a macro, determina sus tipos y llama a code_llvm en la expresión resultante. Establece los argumentos opcionales raw, dump_module, debuginfo, optimize colocando estos y su valor antes de la llamada a la función, así:

@code_llvm raw=true dump_module=true debuginfo=:default f(x)
@code_llvm optimize=false f(x)

optimize controla si se aplican optimizaciones adicionales, como la inlining. raw hace que todos los metadatos y llamadas dbg.* sean visibles. debuginfo puede ser uno de :source (por defecto) o :none, para especificar la verbosidad de los comentarios del código. dump_module imprime todo el módulo que encapsula la función.

Ver también: code_llvm, @code_warntype, @code_typed, @code_lowered, @code_native.

code_native([io=stdout,], f, types; syntax=:intel, debuginfo=:default, binary=false, dump_module=true)

Imprime las instrucciones de ensamblaje nativo generadas para ejecutar el método que coincide con la función genérica y la firma de tipo dadas en io.

• Establece la sintaxis de ensamblaje configurando syntax a :intel (predeterminado) para la sintaxis intel o :att para la sintaxis AT&T.
• Especifica la verbosidad de los comentarios de código configurando debuginfo a :source (predeterminado) o :none.
• Si binary es true, también imprime el código de máquina binario para cada instrucción precedido por una dirección abreviada.
• Si dump_module es false, no imprime metadatos como rodata o directivas.
• Si raw es false, se omiten instrucciones poco interesantes (como el prólogo de la función de safepoint).

Ver también: @code_native, code_warntype, code_typed, code_lowered, code_llvm.

@code_native

Evalúa los argumentos de la llamada a la función o macro, determina sus tipos y llama a code_native en la expresión resultante.

Establece cualquiera de los argumentos opcionales syntax, debuginfo, binary o dump_module colocándolo antes de la llamada a la función, así:

@code_native syntax=:intel debuginfo=:default binary=true dump_module=false f(x)

• Establece la sintaxis de ensamblador configurando syntax a :intel (predeterminado) para la sintaxis Intel o :att para la sintaxis AT&T.
• Especifica la verbosidad de los comentarios de código configurando debuginfo a :source (predeterminado) o :none.
• Si binary es true, también imprime el código de máquina binario para cada instrucción precedido por una dirección abreviada.
• Si dump_module es false, no imprime metadatos como rodata o directivas.

Consulta también: code_native, @code_warntype, @code_typed, @code_lowered, @code_llvm.

@time_imports

Una macro para ejecutar una expresión y producir un informe de cualquier tiempo gastado importando paquetes y sus dependencias. Cualquier tiempo de compilación se informará como un porcentaje, y cuánto de eso fue recompilación, si la hubo.

Se imprime una línea por paquete o extensión de paquete. La duración mostrada es el tiempo para importar ese paquete en sí, sin incluir el tiempo para cargar ninguna de sus dependencias.

En Julia 1.9+ extensiones de paquete se mostrarán como Padre → Extensión.

julia> @time_imports using CSV
     50.7 ms  Parsers 17.52% tiempo de compilación
      0.2 ms  DataValueInterfaces
      1.6 ms  DataAPI
      0.1 ms  IteratorInterfaceExtensions
      0.1 ms  TableTraits
     17.5 ms  Tables
     26.8 ms  PooledArrays
    193.7 ms  SentinelArrays 75.12% tiempo de compilación
      8.6 ms  InlineStrings
     20.3 ms  WeakRefStrings
      2.0 ms  TranscodingStreams
      1.4 ms  Zlib_jll
      1.8 ms  CodecZlib
      0.8 ms  Compat
     13.1 ms  FilePathsBase 28.39% tiempo de compilación
   1681.2 ms  CSV 92.40% tiempo de compilación

clipboard(x)

Envía una forma impresa de x al portapapeles del sistema operativo ("copiar").

clipboard() -> String

Devuelve una cadena con el contenido del portapapeles del sistema operativo ("pegar").