Interactive Utilities

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

Recherchez les docstrings disponibles pour les entrées contenant pattern.

Lorsque pattern est une chaîne, la casse est ignorée. Les résultats sont imprimés dans io.

apropos peut être appelé depuis le mode d'aide dans le REPL en entourant la requête de guillemets doubles :

help?> "pattern"

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

Retourne un tableau markdown donnant des informations sur les variables globales publiques dans un module, éventuellement restreintes à celles correspondant à pattern.

L'estimation de la consommation mémoire est une limite inférieure approximative de la taille de la structure interne de l'objet.

• all : liste également les objets non publics définis dans le module, les objets obsolètes et les objets générés par le compilateur.
• imported : liste également les objets explicitement importés d'autres modules.
• recursive : inclut récursivement les objets dans les sous-modules, en respectant les mêmes paramètres dans chaque.
• sortby : la colonne par laquelle trier les résultats. Les options sont :name (par défaut), :size et :summary.
• minsize : inclut uniquement les objets d'une taille d'au moins minsize octets. Par défaut, c'est 0.

La sortie de varinfo est destinée à des fins d'affichage uniquement. Voir aussi names pour obtenir un tableau de symboles définis dans un module, qui est adapté à des manipulations plus générales.

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

Imprime des informations sur la version de Julia en cours d'utilisation. La sortie est contrôlée par des arguments clés booléens :

• verbose : imprimer toutes les informations supplémentaires

Voir aussi : VERSION.

methodswith(typ[, module ou fonction]; supertypes::Bool=false])

Renvoie un tableau de méthodes avec un argument de type typ.

Le deuxième argument optionnel restreint la recherche à un module ou une fonction particulière (la valeur par défaut est tous les modules de niveau supérieur).

Si le mot-clé supertypes est true, renvoie également les arguments avec un type parent de typ, en excluant le type Any.

Voir aussi : methods.

subtypes(T::DataType)

Renvoie une liste des sous-types immédiats du type de données T. Notez que tous les sous-types actuellement chargés sont inclus, y compris ceux qui ne sont pas visibles dans le module actuel.

Voir aussi supertype, supertypes, methodswith.

Exemples

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

supertypes(T::Type)

Renvoie un tuple (T, ..., Any) de T et de tous ses supertypes, déterminé par des appels successifs à la fonction supertype, listés dans l'ordre de <: et terminés par Any.

Voir aussi subtypes.

Exemples

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

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

Modifiez un fichier ou un répertoire en fournissant éventuellement un numéro de ligne pour modifier le fichier à cet endroit. Retournez à l'invite julia lorsque vous quittez l'éditeur. L'éditeur peut être changé en définissant JULIA_EDITOR, VISUAL ou EDITOR en tant que variable d'environnement.

Voir aussi InteractiveUtils.define_editor.

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

Modifiez la définition d'une fonction, en spécifiant éventuellement un tuple de types pour indiquer quelle méthode modifier. Pour les modules, ouvrez le fichier source principal. Le module doit d'abord être chargé avec using ou import.

Pour vous assurer que le fichier peut être ouvert à la ligne donnée, vous devrez peut-être appeler InteractiveUtils.define_editor d'abord.

@edit

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle la fonction edit sur l'expression résultante.

Voir aussi : @less, @which.

define_editor(fn, pattern; wait=false)

Définir un nouvel éditeur correspondant à pattern qui peut être utilisé pour ouvrir un fichier (éventuellement à un numéro de ligne donné) en utilisant fn.

L'argument fn est une fonction qui détermine comment ouvrir un fichier avec l'éditeur donné. Il doit prendre quatre arguments, comme suit :

• cmd - un objet de commande de base pour l'éditeur
• path - le chemin vers le fichier source à ouvrir
• line - le numéro de ligne pour ouvrir l'éditeur
• column - le numéro de colonne pour ouvrir l'éditeur

Les éditeurs qui ne peuvent pas s'ouvrir à une ligne spécifique avec une commande ou une colonne spécifique peuvent ignorer l'argument line et/ou column. Le rappel fn doit retourner soit un objet Cmd approprié pour ouvrir un fichier, soit nothing pour indiquer qu'ils ne peuvent pas éditer ce fichier. Utilisez nothing pour indiquer que cet éditeur n'est pas approprié pour l'environnement actuel et qu'un autre éditeur doit être tenté. Il est possible d'ajouter des hooks d'édition plus généraux qui n'ont pas besoin de lancer des commandes externes en poussant un rappel directement dans le vecteur EDITOR_CALLBACKS.

L'argument pattern est une chaîne, une expression régulière ou un tableau de chaînes et d'expressions régulières. Pour que fn soit appelé, l'un des motifs doit correspondre à la valeur de EDITOR, VISUAL ou JULIA_EDITOR. Pour les chaînes, la chaîne doit être égale à la basename du premier mot de la commande de l'éditeur, avec son extension, le cas échéant, supprimée. Par exemple, "vi" ne correspond pas à "vim -g" mais correspond à "/usr/bin/vi -m" ; elle correspond également à vi.exe. Si pattern est une regex, elle est comparée à toute la commande de l'éditeur sous forme de chaîne échappée par le shell. Un motif de tableau correspond si l'un de ses éléments correspond. Si plusieurs éditeurs correspondent, celui ajouté le plus récemment est utilisé.

Par défaut, julia n'attend pas que l'éditeur se ferme, l'exécutant en arrière-plan. Cependant, si l'éditeur est basé sur un terminal, vous voudrez probablement définir wait=true et julia attendra que l'éditeur se ferme avant de reprendre.

Si l'une des variables d'environnement de l'éditeur est définie, mais qu'aucune entrée d'éditeur ne correspond, l'entrée d'éditeur par défaut est invoquée :

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

Notez que de nombreux éditeurs sont déjà définis. Toutes les commandes suivantes devraient déjà fonctionner :

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

Exemples

Le suivant définit l'utilisation de emacs basé sur un 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])

Affiche un fichier en utilisant le pager par défaut, en fournissant éventuellement un numéro de ligne de départ. Retourne à l'invite julia lorsque vous quittez le pager.

less(function, [types])

Affiche la définition d'une fonction en utilisant le pager par défaut, en spécifiant éventuellement un tuple de types pour indiquer quelle méthode voir.

@less

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle la fonction less sur l'expression résultante.

Voir aussi : @edit, @which, @code_lowered.

@which

Appliqué à un appel de fonction ou de macro, il évalue les arguments de l'appel spécifié et renvoie l'objet Method pour la méthode qui serait appelée pour ces arguments. Appliqué à une variable, il renvoie le module dans lequel la variable a été liée. Il appelle la fonction which.

Voir aussi : @less, @edit.

@functionloc

Appliqué à un appel de fonction ou de macro, il évalue les arguments de l'appel spécifié et renvoie un tuple (nom_fichier, ligne) donnant l'emplacement de la méthode qui serait appelée pour ces arguments. Il appelle la fonction functionloc.

@code_lowered

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle code_lowered sur l'expression résultante.

Voir aussi : code_lowered, @code_warntype, @code_typed, @code_llvm, @code_native.

@code_typed

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle code_typed sur l'expression résultante. Utilisez l'argument optionnel optimize avec

@code_typed optimize=true foo(x)

pour contrôler si des optimisations supplémentaires, telles que l'inlining, sont également appliquées.

Voir aussi : code_typed, @code_warntype, @code_lowered, @code_llvm, @code_native.

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

Imprime les AST abaissés et inférés par type pour les méthodes correspondant à la fonction générique donnée et à la signature de type pour io, qui par défaut est stdout. Les AST sont annotés de manière à mettre en évidence les types "non-feuilles" qui peuvent poser des problèmes de performance (s'ils sont disponibles en couleur, affichés en rouge). Cela sert d'avertissement sur une éventuelle instabilité de type.

Tous les types non-feuilles ne sont pas particulièrement problématiques pour la performance, et les caractéristiques de performance d'un type particulier sont un détail d'implémentation du compilateur. code_warntype aura tendance à colorer les types en rouge s'ils pourraient poser un problème de performance, donc certains types peuvent être colorés en rouge même s'ils n'impactent pas la performance. Les petites unions de types concrets ne posent généralement pas de problème, donc celles-ci sont mises en évidence en jaune.

L'argument clé debuginfo peut être l'un de :source ou :none (par défaut), pour spécifier la verbosité des commentaires de code.

Voir la section @code_warntype dans la page des Conseils de Performance du manuel pour plus d'informations.

Voir aussi : @code_warntype, code_typed, code_lowered, code_llvm, code_native.

@code_warntype

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle code_warntype sur l'expression résultante.

Voir aussi : 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 les bitcodes LLVM générés pour l'exécution de la méthode correspondant à la fonction générique donnée et à la signature de type dans io.

Si le mot-clé optimize n'est pas défini, le code sera affiché avant les optimisations LLVM. Toutes les métadonnées et les appels dbg.* sont supprimés du bitcode imprimé. Pour obtenir l'IR complet, définissez le mot-clé raw sur true. Pour afficher l'ensemble du module qui encapsule la fonction (avec les déclarations), définissez le mot-clé dump_module sur true. L'argument clé debuginfo peut être l'un de source (par défaut) ou none, pour spécifier la verbosité des commentaires de code.

Voir aussi : @code_llvm, code_warntype, code_typed, code_lowered, code_native.

@code_llvm

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle code_llvm sur l'expression résultante. Définissez les arguments de mot-clé optionnels raw, dump_module, debuginfo, optimize en les plaçant avec leur valeur avant l'appel de fonction, comme ceci :

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

optimize contrôle si des optimisations supplémentaires, telles que l'inlining, sont également appliquées. raw rend toutes les métadonnées et les appels dbg.* visibles. debuginfo peut être l'un de :source (par défaut) ou :none, pour spécifier la verbosité des commentaires de code. dump_module imprime l'ensemble du module qui encapsule la fonction.

Voir aussi : 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 les instructions d'assemblage natif générées pour exécuter la méthode correspondant à la fonction générique donnée et à la signature de type dans io.

• Définissez la syntaxe d'assemblage en réglant syntax sur :intel (par défaut) pour la syntaxe intel ou :att pour la syntaxe AT&T.
• Spécifiez la verbosité des commentaires de code en réglant debuginfo sur :source (par défaut) ou :none.
• Si binary est true, imprimez également le code machine binaire pour chaque instruction précédé d'une adresse abrégée.
• Si dump_module est false, ne pas imprimer les métadonnées telles que rodata ou directives.
• Si raw est false, les instructions peu intéressantes (comme le prologue de la fonction de point de sécurité) sont omises.

Voir aussi : @code_native, code_warntype, code_typed, code_lowered, code_llvm.

@code_native

Évalue les arguments de l'appel de fonction ou de macro, détermine leurs types et appelle code_native sur l'expression résultante.

Définissez n'importe quel des arguments optionnels syntax, debuginfo, binary ou dump_module en les plaçant avant l'appel de fonction, comme ceci :

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

• Définissez la syntaxe d'assemblage en réglant syntax sur :intel (par défaut) pour la syntaxe Intel ou :att pour la syntaxe AT&T.
• Spécifiez la verbosité des commentaires de code en réglant debuginfo sur :source (par défaut) ou :none.
• Si binary est true, imprimez également le code machine binaire pour chaque instruction précédée d'une adresse abrégée.
• Si dump_module est false, ne pas imprimer les métadonnées telles que rodata ou directives.

Voir aussi : code_native, @code_warntype, @code_typed, @code_lowered, @code_llvm.

@time_imports

Une macro pour exécuter une expression et produire un rapport de tout le temps passé à importer des packages et leurs dépendances. Tout le temps de compilation sera rapporté en pourcentage, ainsi que la part de recompilation, le cas échéant.

Une ligne est imprimée par package ou extension de package. La durée affichée est le temps pour importer ce package lui-même, sans inclure le temps pour charger ses dépendances.

Sur Julia 1.9+ package extensions apparaîtra comme Parent → Extension.

julia> @time_imports using CSV
     50.7 ms  Parsers 17.52% temps de compilation
      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% temps de compilation
      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% temps de compilation
   1681.2 ms  CSV 92.40% temps de compilation

clipboard(x)

Envoie une forme imprimée de x au presse-papiers du système d'exploitation ("copier").

clipboard() -> String

Renvoie une chaîne contenant le contenu du presse-papiers du système d'exploitation ("coller").