Interactive Utilities

Base.Docs.apropos — Function.

  1. apropos(string)

Search through all documentation for a string, ignoring case.

source

InteractiveUtils.varinfo — Function.

  1. varinfo(m::Module=Main, pattern::Regex=r"")

Return a markdown table giving information about exported global variables in a module, optionally restricted to those matching pattern.

The memory consumption estimate is an approximate lower bound on the size of the internal structure of the object.

source

InteractiveUtils.versioninfo — Function.

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

Print information about the version of Julia in use. The output is controlled with boolean keyword arguments:

  • verbose: print all additional information

source

InteractiveUtils.methodswith — Function.

  1. methodswith(typ[, module or function]; supertypes::Bool=false])

Return an array of methods with an argument of type typ.

The optional second argument restricts the search to a particular module or function (the default is all top-level modules).

If keyword supertypes is true, also return arguments with a parent type of typ, excluding type Any.

source

InteractiveUtils.subtypes — Function.

  1. subtypes(T::DataType)

Return a list of immediate subtypes of DataType T. Note that all currently loaded subtypes are included, including those not visible in the current module.

Examples

  1. julia> subtypes(Integer)
  2. 3-element Array{Any,1}:
  3.  Bool
  4.  Signed
  5.  Unsigned

source

InteractiveUtils.edit — Method.

  1. edit(path::AbstractString, line::Integer=0)

Edit a file or directory optionally providing a line number to edit the file at. Return to the julia prompt when you quit the editor. The editor can be changed by setting JULIA_EDITOR, VISUAL or EDITOR as an environment variable.

source

InteractiveUtils.edit — Method.

  1. edit(function, [types])
  2. edit(module)

Edit the definition of a function, optionally specifying a tuple of types to indicate which method to edit. For modules, open the main source file. The module needs to be loaded with using or import first.

Julia 1.1

edit on modules requires at least Julia 1.1.

The editor can be changed by setting JULIA_EDITOR, VISUAL or EDITOR as an environment variable.

source

InteractiveUtils.@edit — Macro.

  1. @edit

Evaluates the arguments to the function or macro call, determines their types, and calls the edit function on the resulting expression.

source

InteractiveUtils.less — Method.

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

Show a file using the default pager, optionally providing a starting line number. Returns to the julia prompt when you quit the pager.

source

InteractiveUtils.less — Method.

  1. less(function, [types])

Show the definition of a function using the default pager, optionally specifying a tuple of types to indicate which method to see.

source

InteractiveUtils.@less — Macro.

  1. @less

Evaluates the arguments to the function or macro call, determines their types, and calls the less function on the resulting expression.

source

InteractiveUtils.@which — Macro.

  1. @which

Applied to a function or macro call, it evaluates the arguments to the specified call, and returns the Method object for the method that would be called for those arguments. Applied to a variable, it returns the module in which the variable was bound. It calls out to the which function.

source

InteractiveUtils.@functionloc — Macro.

  1. @functionloc

Applied to a function or macro call, it evaluates the arguments to the specified call, and returns a tuple (filename,line) giving the location for the method that would be called for those arguments. It calls out to the functionloc function.

source

InteractiveUtils.@code_lowered — Macro.

  1. @code_lowered

Evaluates the arguments to the function or macro call, determines their types, and calls code_lowered on the resulting expression.

source

InteractiveUtils.@code_typed — Macro.

  1. @code_typed

Evaluates the arguments to the function or macro call, determines their types, and calls code_typed on the resulting expression. Use the optional argument optimize with

  1. @code_typed optimize=true foo(x)

to control whether additional optimizations, such as inlining, are also applied.

source

InteractiveUtils.code_warntype — Function.

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

Prints lowered and type-inferred ASTs for the methods matching the given generic function and type signature to io which defaults to stdout. The ASTs are annotated in such a way as to cause “non-leaf” types to be emphasized (if color is available, displayed in red). This serves as a warning of potential type instability. Not all non-leaf types are particularly problematic for performance, so the results need to be used judiciously. In particular, unions containing either missing or nothing are displayed in yellow, since these are often intentional.

Keyword argument debuginfo may be one of source or none (default), to specify the verbosity of code comments.

See @code_warntype for more information.

source

InteractiveUtils.@code_warntype — Macro.

  1. @code_warntype

Evaluates the arguments to the function or macro call, determines their types, and calls code_warntype on the resulting expression.

source

InteractiveUtils.code_llvm — Function.

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

Prints the LLVM bitcodes generated for running the method matching the given generic function and type signature to io.

If the optimize keyword is unset, the code will be shown before LLVM optimizations. All metadata and dbg.* calls are removed from the printed bitcode. For the full IR, set the raw keyword to true. To dump the entire module that encapsulates the function (with declarations), set the dump_module keyword to true. Keyword argument debuginfo may be one of source (default) or none, to specify the verbosity of code comments.

source

InteractiveUtils.@code_llvm — Macro.

  1. @code_llvm

Evaluates the arguments to the function or macro call, determines their types, and calls code_llvm on the resulting expression. Set the optional keyword arguments raw, dump_module, debuginfo, optimize by putting them and their value before the function call, like this:

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

optimize controls whether additional optimizations, such as inlining, are also applied. raw makes all metadata and dbg.* calls visible. debuginfo may be one of full, source (default), none, to specify the verbosity of code comments. dump_module prints the entire module that encapsulates the function.

source

InteractiveUtils.code_native — Function.

  1. code_native([io=stdout,], f, types; syntax=:att, debuginfo=:default)

Prints the native assembly instructions generated for running the method matching the given generic function and type signature to io. Switch assembly syntax using syntax symbol parameter set to :att for AT&T syntax or :intel for Intel syntax. Keyword argument debuginfo may be one of source (default) or none, to specify the verbosity of code comments.

source

InteractiveUtils.@code_native — Macro.

  1. @code_native

Evaluates the arguments to the function or macro call, determines their types, and calls code_native on the resulting expression.

Set the optional keyword argument debuginfo by putting it before the function call, like this:

  1. @code_native debuginfo=:default f(x)

debuginfo may be one of source (default) or none, to specify the verbosity of code comments.

source

InteractiveUtils.clipboard — Function.

  1. clipboard(x)

Send a printed form of x to the operating system clipboard (“copy”).

source

  1. clipboard() -> AbstractString

Return a string with the contents of the operating system clipboard (“paste”).

source