Interactive Utilities

# Interactive Utilities

`Base.Docs.apropos` — Function.

    apropos(string)

Search through all documentation for a string, ignoring case.

source
`InteractiveUtils.varinfo` — Function.

    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.

    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.

    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.

    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

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

source
`InteractiveUtils.edit` — Method.

    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.

    edit(function, [types])
    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.

    @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.

    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.

    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.

    @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.

    @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.

    @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.

    @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.

    @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

    @code_typed optimize=true foo(x)

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

source
`InteractiveUtils.code_warntype` — Function.

    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.

    @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.

    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.

    @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:

    @code_llvm raw=true dump_module=true debuginfo=:default f(x)
    @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 `:source` (default) or `:none`, to specify the verbosity of code comments. `dump_module` prints the entire module that encapsulates the function.

source
`InteractiveUtils.code_native` — Function.

    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.

    @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:

    @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.

    clipboard(x)

Send a printed form of `x` to the operating system clipboard ("copy").

source

    clipboard() -> AbstractString

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

source