Julia REPL

    To exit the interactive session, type ^D – the control key together with the d key on a blank line – or type exit() followed by the return or enter key. The REPL greets you with a banner and a julia> prompt.

    REPL 有四种主要的操作模式。第一个也是最常见的是 Julian 提示符。这是默认的操作模式；每个新行最初都以 julia> 开头。就在这里，你可以输入 Julia 表达式。在输入完整表达式后按下 return 或 enter 将执行该表达式，并显示最后一个表达式的结果。

    1. julia> string(1 + 2)
    2. "3"

    交互式运行有许多独特的实用功能。除了显示结果外，REPL 还将结果绑定到变量 ans 上。一行的尾随分号可用作禁止显示结果的标志。

    1. julia> string(3 * 4);
    3. julia> ans
    4. "12"

    In Julia mode, the REPL supports something called prompt pasting. This activates when pasting text that starts with julia> into the REPL. In that case, only expressions starting with julia> are parsed, others are removed. This makes it is possible to paste a chunk of code that has been copied from a REPL session without having to scrub away prompts and outputs. This feature is enabled by default but can be disabled or enabled at will with REPL.enable_promptpaste(::Bool). If it is enabled, you can try it out by pasting the code block above this paragraph straight into the REPL. This feature does not work on the standard Windows command prompt due to its limitation at detecting when a paste occurs.

    Objects are printed at the REPL using the show function with a specific . In particular, the :limit attribute is set to true. Other attributes can receive in certain show methods a default value if it’s not already set, like :compact. It’s possible, as an experimental feature, to specify the attributes used by the REPL via the Base.active_repl.options.iocontext dictionary (associating values to attributes). For example:

    1. julia> rand(2, 2)
    2. 2×2 Array{Float64,2}:
    3.  0.8833    0.329197
    4.  0.719708  0.59114
    6. julia> show(IOContext(stdout, :compact => false), "text/plain", rand(2, 2))
    7.  0.43540323669187075  0.15759787870609387
    8.  0.2540832269192739   0.4597637838786053
    9. julia> Base.active_repl.options.iocontext[:compact] = false;
    11. julia> rand(2, 2)
    12. 2×2 Array{Float64,2}:
    13.  0.2083967319174056  0.13330606013126012
    14.  0.6244375177790158  0.9777957560761545

    In order to define automatically the values of this dictionary at startup time, one can use the atreplinit function in the ~/.julia/config/startup.jl file, for example:

    1. atreplinit() do repl
    2.     repl.options.iocontext[:compact] = false
    3. end

    Help mode

    When the cursor is at the beginning of the line, the prompt can be changed to a help mode by typing ?. Julia will attempt to print help or documentation for anything entered in help mode:

    1. julia> ? # upon typing ?, the prompt changes (in place) to: help?>
    3. help?> string
    4. search: string String Cstring Cwstring RevString randstring bytestring SubString
    6.   string(xs...)
    8.   Create a string from any values using the print function.

    Macros, types and variables can also be queried:

    1. help?> @time
    2.   @time
    4.   A macro to execute an expression, printing the time it took to execute, the number of allocations,
    5.   and the total number of bytes its execution caused to be allocated, before returning the value of the
    6.   expression.
    8.   See also @timev, @timed, @elapsed, and @allocated.
    10. help?> Int32
    11. search: Int32 UInt32
    13.   Int32 <: Signed
    15.   32-bit signed integer type.

    Help mode can be exited by pressing backspace at the beginning of the line.

    Just as help mode is useful for quick access to documentation, another common task is to use the system shell to execute system commands. Just as ? entered help mode when at the beginning of the line, a semicolon (;) will enter the shell mode. And it can be exited by pressing backspace at the beginning of the line.

    1. julia> ; # upon typing ;, the prompt changes (in place) to: shell>
    3. shell> echo hello
    4. hello

    Note

    For Windows users, Julia’s shell mode does not expose windows shell commands. Hence, this will fail:

    1. julia> ; # upon typing ;, the prompt changes (in place) to: shell>
    3. shell> dir
    4. ERROR: IOError: could not spawn `dir`: no such file or directory (ENOENT)
    5. Stacktrace!
    6. .......

    However, you can get access to PowerShell like this:

    1. julia> ; # upon typing ;, the prompt changes (in place) to: shell>
    3. shell> powershell
    4. Windows PowerShell
    5. Copyright (C) Microsoft Corporation. All rights reserved.
    6. PS C:\Users\elm>

    … and to cmd.exe like that (see the dir command):

    Search modes

    Just as ^R is a reverse search, ^S is a forward search, with the prompt (i-search)`':. The two may be used in conjunction with each other to move through the previous or next matching results, respectively.

    Key bindings

    The Julia REPL makes great use of key bindings. Several control-key bindings were already introduced above (^D to exit, ^R and ^S for searching), but there are many more. In addition to the control-key, there are also meta-key bindings. These vary more by platform, but most terminals default to using alt- or option- held down with a key to send the meta-key (or can be configured to do so), or pressing Esc and then the key.

    Julia’s REPL keybindings may be fully customized to a user’s preferences by passing a dictionary to REPL.setup_interface. The keys of this dictionary may be characters or strings. The key '*' refers to the default action. Control plus character x bindings are indicated with "^x". Meta plus x can be written "\\M-x" or "\ex", and Control plus x can be written "\\C-x" or "^x". The values of the custom keymap must be nothing (indicating that the input should be ignored) or functions that accept the signature (PromptState, AbstractREPL, Char). The REPL.setup_interface function must be called before the REPL is initialized, by registering the operation with atreplinit . For example, to bind the up and down arrow keys to move through history without prefix search, one could put the following code in ~/.julia/config/startup.jl:

    1. import REPL
    2. import REPL.LineEdit
    4. const mykeys = Dict{Any,Any}(
    5.     # Up Arrow
    6.     "\e[A" => (s,o...)->(LineEdit.edit_move_up(s) || LineEdit.history_prev(s, LineEdit.mode(s).hist)),
    7.     # Down Arrow
    8.     "\e[B" => (s,o...)->(LineEdit.edit_move_down(s) || LineEdit.history_next(s, LineEdit.mode(s).hist))
    9. )
    11.     repl.interface = REPL.setup_interface(repl; extra_repl_keymap = mykeys)
    12. end
    14. atreplinit(customize_keys)

    Users should refer to LineEdit.jl to discover the available actions on key input.

    In both the Julian and help modes of the REPL, one can enter the first few characters of a function or type and then press the tab key to get a list all matches:

    1. julia> stri[TAB]
    2. stride     strides     string      strip
    4. julia> Stri[TAB]
    5. StridedArray    StridedMatrix    StridedVecOrMat  StridedVector    String

    The tab key can also be used to substitute LaTeX math symbols with their Unicode equivalents, and get a list of LaTeX matches as well:

    1. julia> \pi[TAB]
    2. julia> π
    3. π = 3.1415926535897...
    5. julia> e\_1[TAB] = [1,0]
    6. julia> e₁ = [1,0]
    7. 2-element Array{Int64,1}:
    8.  1
    9.  0
    11. julia> e\^1[TAB] = [1 0]
    12. julia> e¹ = [1 0]
    13. 1×2 Array{Int64,2}:
    14.  1  0
    16. julia> \sqrt[TAB]2     # √ is equivalent to the sqrt function
    17. julia> √2
    18. 1.4142135623730951
    20. julia> \hbar[TAB](h) = h / 2\pi[TAB]
    21. julia> ħ(h) = h / 2π
    22. ħ (generic function with 1 method)
    24. julia> \h[TAB]
    25. \hat              \hermitconjmatrix  \hkswarow          \hrectangle
    26. \hatapprox        \hexagon           \hookleftarrow     \hrectangleblack
    27. \hbar             \hexagonblack      \hookrightarrow    \hslash
    28. \heartsuit        \hksearow          \house             \hspace
    30. julia> α="\alpha[TAB]"   # LaTeX completion also works in strings
    31. julia> α="α"

    A full list of tab-completions can be found in the section of the manual.

    Completion of paths works for strings and julia’s shell mode:

    1. julia> path="/[TAB]"
    2. .dockerenv  .juliabox/   boot/        etc/         lib/         media/       opt/         root/        sbin/        sys/         usr/
    3. .dockerinit bin/         dev/         home/        lib64/       mnt/         proc/        run/         srv/         tmp/         var/
    4. shell> /[TAB]
    5. .dockerenv  .juliabox/   boot/        etc/         lib/         media/       opt/         root/        sbin/        sys/         usr/
    6. .dockerinit bin/         dev/         home/        lib64/       mnt/         proc/        run/         srv/         tmp/         var/

    Tab completion can help with investigation of the available methods matching the input arguments:

    1. julia> max([TAB] # All methods are displayed, not shown here due to size of the list
    3. julia> max([1, 2], [TAB] # All methods where `Vector{Int}` matches as first argument
    4. max(x, y) in Base at operators.jl:215
    5. max(a, b, c, xs...) in Base at operators.jl:281
    7. julia> max([1, 2], max(1, 2), [TAB] # All methods matching the arguments.
    8. max(x, y) in Base at operators.jl:215
    9. max(a, b, c, xs...) in Base at operators.jl:281

    Keywords are also displayed in the suggested methods after ;, see below line where limit and keepempty are keyword arguments:

    1. julia> split("1 1 1", [TAB]
    2. split(str::AbstractString; limit, keepempty) in Base at strings/util.jl:302
    3. split(str::T, splitter; limit, keepempty) where T<:AbstractString in Base at strings/util.jl:277

    The completion of the methods uses type inference and can therefore see if the arguments match even if the arguments are output from functions. The function needs to be type stable for the completion to be able to remove non-matching methods.

    Tab completion can also help completing fields:

    1. julia> import UUIDs
    3. julia> UUIDs.uuid[TAB]
    4. uuid1        uuid4         uuid_version

    Fields for output from functions can also be completed:

    1. julia> split("","")[1].[TAB]
    2. lastindex  offset  string

    The completion of fields for output from functions uses type inference, and it can only suggest fields if the function is type stable.

    1. julia> foo = Dict("qwer1"=>1, "qwer2"=>2, "asdf"=>3)
    2. Dict{String,Int64} with 3 entries:
    3.   "qwer2" => 2
    4.   "asdf"  => 3
    5.   "qwer1" => 1
    7. julia> foo["q[TAB]
    9. "qwer1" "qwer2"
    10. julia> foo["qwer

    Customizing Colors

    The colors used by Julia and the REPL can be customized, as well. To change the color of the Julia prompt you can add something like the following to your ~/.julia/config/startup.jl file, which is to be placed inside your home directory:

    The available color keys can be seen by typing Base.text_colors in the help mode of the REPL. In addition, the integers 0 to 255 can be used as color keys for terminals with 256 color support.

    You can also change the colors for the help and shell prompts and input and answer text by setting the appropriate field of repl in the customize_colors function above (respectively, , shell_color, input_color, and answer_color). For the latter two, be sure that the envcolors field is also set to false.

    It is also possible to apply boldface formatting by using Base.text_colors[:bold] as a color. For instance, to print answers in boldface font, one can use the following as a ~/.julia/config/startup.jl:

    1. function customize_colors(repl)
    2.     repl.envcolors = false
    3.     repl.answer_color = Base.text_colors[:bold]
    4. end
    6. atreplinit(customize_colors)

    You can also customize the color used to render warning and informational messages by setting the appropriate environment variables. For instance, to render error, warning, and informational messages respectively in magenta, yellow, and cyan you can add the following to your ~/.julia/config/startup.jl file:

    1. ENV["JULIA_ERROR_COLOR"] = :magenta
    2. ENV["JULIA_WARN_COLOR"] = :yellow
    3. ENV["JULIA_INFO_COLOR"] = :cyan

    TerminalMenus is a submodule of the Julia REPL and enables small, low-profile interactive menus in the terminal.

    Examples

    1. import REPL
    2. using REPL.TerminalMenus
    4. options = ["apple", "orange", "grape", "strawberry",
    5.             "blueberry", "peach", "lemon", "lime"]

    RadioMenu

    The RadioMenu allows the user to select one option from the list. The request function displays the interactive menu and returns the index of the selected choice. If a user presses ‘q’ or ctrl-c, request will return a -1.

    1. # `pagesize` is the number of items to be displayed at a time.
    2. #   than the `pagesize`
    3. menu = RadioMenu(options, pagesize=4)
    5. # `request` displays the menu and returns the index after the
    6. #   user has selected a choice
    7. choice = request("Choose your favorite fruit:", menu)
    9. if choice != -1
    10.     println("Your favorite fruit is ", options[choice], "!")
    11. else
    12.     println("Menu canceled.")
    13. end

    Output:

    1. Choose your favorite fruit:
    2. ^  grape
    3.    strawberry
    4.  > blueberry
    5. v  peach
    6. Your favorite fruit is blueberry!

    MultiSelectMenu

    The MultiSelectMenu allows users to select many choices from a list.

    1. # here we use the default `pagesize` 10
    2. menu = MultiSelectMenu(options)
    4. # `request` returns a `Set` of selected indices
    5. # if the menu us canceled (ctrl-c or q), return an empty set
    6. choices = request("Select the fruits you like:", menu)
    8. if length(choices) > 0
    9.     println("You like the following fruits:")
    10.     for i in choices
    11.         println("  - ", options[i])
    12.     end
    13. else
    14.     println("Menu canceled.")
    15. end

    Output:

    1. Select the fruits you like:
    2. [press: d=done, a=all, n=none]
    3.    [ ] apple
    4.  > [X] orange
    5.    [X] grape
    6.    [ ] strawberry
    7.    [ ] blueberry
    8.    [X] peach
    9.    [ ] lemon
    10.    [ ] lime
    11. You like the following fruits:
    12.   - orange
    13.   - grape
    14.   - peach

    All interface customization is done through the keyword only TerminalMenus.config() function.

    Arguments

    • charset::Symbol=:na: ui characters to use (:ascii or :unicode); overridden by other arguments
    • cursor::Char='>'|'→': character to use for cursor
    • up_arrow::Char='^'|'↑': character to use for up arrow
    • down_arrow::Char='v'|'↓': character to use for down arrow
    • checked::String="[X]"|"✓": string to use for checked
    • unchecked::String="[ ]"|"⬚"): string to use for unchecked
    • scroll::Symbol=:na: If :wrap then wrap the cursor around top and bottom, if :nowrap do not wrap cursor
    • supress_output::Bool=false: For testing. If true, menu will not be printed to console.
    • ctrl_c_interrupt::Bool=true: If false, return empty on ^C, if true throw InterruptException() on ^C

    Examples

    1. julia> menu = MultiSelectMenu(options, pagesize=5);
    3. julia> request(menu) # ASCII is used by default
    4. [press: d=done, a=all, n=none]
    5.    [ ] apple
    6.    [X] orange
    7.    [ ] grape
    8.  > [X] strawberry
    9. v  [ ] blueberry
    10. Set([4, 2])
    12. julia> TerminalMenus.config(charset=:unicode)
    14. julia> request(menu)
    15. [press: d=done, a=all, n=none]
    16.    ⬚ apple
    17.    ✓ orange
    18.    ⬚ grape
    19.  → ✓ strawberry
    20. ↓  ⬚ blueberry
    21. Set([4, 2])
    23. julia> TerminalMenus.config(checked="YEP!", unchecked="NOPE", cursor='⧐')
    25. julia> request(menu)
    26. [press: d=done, a=all, n=none]
    27.    NOPE apple
    28.    YEP! orange
    29.    NOPE grape
    30.  ⧐ YEP! strawberry
    31. ↓  NOPE blueberry
    32. Set([4, 2])

    References

    — Function

    1. atreplinit(f)

    Register a one-argument function to be called before the REPL interface is initialized in interactive sessions; this is useful to customize the interface. The argument of f is the REPL object. This function should be called from within the initialization file.

    source