Skip to content

Conversation

tecosaur
Copy link
Member

@tecosaur tecosaur commented Oct 21, 2023

This PR is the result of three thoughts:

  1. versions.jl is a weird place for the banner function to live, when we have REPL
  2. It's annoying when the banner either (nearly) takes up the entire terminal frame, or actually reflows and breaks (visually)
  3. The banner could be a little fancier, visually

The result of these three thoughts is a set of six banner sizes, selected based on displaysize to ensure that this never happens:

The variants below are outdated, see this comment for more up-to-date screenshots: #51811 (comment)

The six variants (outdated)


There are two issues I'm currently facing that I'd appreciate help with:

  1. Precompilation annoyances: it seems I need to change the eval in StyledStrings/src/stylemacro.jl to Core.eval(__module__ during precompile, even if the code is pure. Furthermore, I find myself needing to change the clause on line 669 to state.interpolated[] || Base.generating_output(). This seems a little dodgy, and so I'd appreciate thoughts.
  2. [solved] For some reason, with this PR the banner doesn't appear on starting julia. Yet, as seen by the screenshot above invoking REPL.banner does work. I have confirmed that REPL.banner is indeed called, and so find myself at a loss here.

@tecosaur tecosaur added REPL Julia's REPL (Read Eval Print Loop) display and printing Aesthetics and correctness of printed representations of objects. labels Oct 21, 2023
@IanButterworth
Copy link
Member

Some relevant discussion #25587 (comment)

@longemen3000
Copy link
Contributor

longemen3000 commented Oct 21, 2023

A long time ago i made a package that replaced the default banner with an adaptative one https://github.com/longemen3000/BetterBanner.jl . In my particular implementation, The banner graphics stay the same, but I start adding line breaks to some text present in the banner

@tecosaur
Copy link
Member Author

tecosaur commented Oct 22, 2023

Some relevant discussion #25587 (comment)

Interesting. The rounded j is intruiging.

A long time ago i made a package that replaced the default banner with an adaptative one https://github.com/longemen3000/BetterBanner.jl. In my particular implementation, The banner graphics stay the same, but I start adding line breaks to some text present in the banner

I've seen this 🙂. While that does (mostly) solve the matter of narrower terminals, it doesn't help with how (IMO at least) it looks a bit silly when the banner takes up most of the terminal. For instance, here's me opening a squat terminal with this PR:

image

The braille dots approach is interesting though, and I think your screenshots don't do it justice.

image

@tecosaur
Copy link
Member Author

Ok, I've solved problem (2), and it's a classic coding-when-you-should-have-been-asleep thing. I had || instead of && 🤦

@laborg
Copy link
Contributor

laborg commented Oct 22, 2023

Bikeshedding: I like the braille dots "Julia", and dislike how Julia is printed in variant 4 and 5. Better to not show it at all in this case.

@tecosaur
Copy link
Member Author

Julia 5/4 are for slightly but not extremely squat/narrow terminals.

If we remove 4, we'd jump straight to 2, which I think is too aggressively shrunk.

@KristofferC
Copy link
Member

Some opinions:

  • You must have a very small terminal for the current logo to have an "issue" (61 rows). This issue rarely occurs in practice but if it happens I think just moving the text under the logo is enough, no real need for a separate logo for all permutations of heights and widths.
  • What's the reason for banner versions 5 and 4 (with the number being the argument to banner)? They don't look any more narrow than the original one.
  • The logo in versions 3 and 2 looks very different from any other Julia logo and is not really "on brand" so I personally don't like those.
  • Generally, changes and code movements should happen in different PRs so they can be more easily tracked. So IMO there should be one PR that moves the code and then a second one that implements the changes. Otherwise the code movement is stuck here on bike shedding.

@tecosaur
Copy link
Member Author

Thanks for the thoughts Kristoffer.

  1. I find that very short or narrow terminals appear more often when they're opened within another application (e.g. editor, file manager), and can occur in tiling situations
  2. I'm getting the picture that the current set of options is too adventurous. I might try cutting this down to ~4 variants which don't depart from the current logo style, an leave further styling discussion to the future
  3. Regarding "Generally, changes and code movements should happen in different PRs so they can be more easily tracked.", isn't separate commits good enough? That should be amply clear in the git log.
    Oh, with "Otherwise the code movement is stuck here on bike shedding." the movement is required for the banner rewrite to occur. In addition to seeming like a more sensible home, REPL can load StyledStrings but Client.jl can't (without extra shenanigans).

@PallHaraldsson
Copy link
Contributor

PallHaraldsson commented Oct 23, 2023

How about merging this with version 5 as the default, and having one other option: julia --banner=short (and defaulting to if very narrow). I like stuff moved out of Base, and not too concerned about bloating REPL, so could go either way on having many options, but it seems it can also go into a (already existing) package.

I also like the like the braille dots "Julia", maybe even more, I just have concerns about not all terminals supporting? If not such could/should be the new default. We could even merge such versions since for master/1.11 to begin with, to see if people object/it doesn't work.

@tecosaur
Copy link
Member Author

Regarding precompiling, with --startup-fileno --trace-compile=... I find only a ~4 method difference out of ~750, but I do feel like the latency is a bit higher than it should be?

The extra time (benchmarking REPL.banner) is on the order of μs, so there shouldn't be any perceivable difference if we precompile the right calls.

The trace-compile output
precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Any}})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Nothing, Nothing, StyledStrings.SimpleColor, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{Type{Array{String, 1}}})
precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Any}})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Nothing, Nothing, StyledStrings.SimpleColor, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{typeof(REPL.include), String})
precompile(Tuple{Type{REPL.Options}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Base.PkgId, String}, Union{Nothing, Tuple{Base.PkgId, Union{Nothing, String}}}}, Tuple{Base.PkgId, Nothing}, Tuple{Base.PkgId, String}})
precompile(Tuple{typeof(Base.getindex), Type{Union{Expr, Symbol}}, Symbol, Symbol, Symbol, Vararg{Any}})
precompile(Tuple{typeof(Base.afoldl), Base.var"#115#116"{Array{Union{Expr, Symbol}, 1}}, Int64, Symbol, Symbol, Symbol, Symbol, Expr, Vararg{Symbol, 14}})
precompile(Tuple{typeof(Base.iterate), Array{Union{Expr, Symbol}, 1}})
precompile(Tuple{typeof(Base.iterate), Array{Union{Expr, Symbol}, 1}, Int64})
precompile(Tuple{Type{Pair{A, B} where B where A}, Symbol, Array{Symbol, 1}})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Pair{Symbol, Array{Symbol, 1}}, Vararg{Pair{Symbol, Array{Symbol, 1}}}})
precompile(Tuple{Type{Base.Dict{Symbol, Array{Symbol, 1}}}, NTuple{6, Pair{Symbol, Array{Symbol, 1}}}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#9#10", Base.Dict{Symbol, Array{Symbol, 1}}})
precompile(Tuple{Type{Base.Iterators.Flatten{I} where I}, Base.Generator{Base.Dict{Symbol, Array{Symbol, 1}}, REPL.LineEdit.var"#9#10"}})
precompile(Tuple{Type{Base.Dict{Symbol, Symbol}}, Base.Iterators.Flatten{Base.Generator{Base.Dict{Symbol, Array{Symbol, 1}}, REPL.LineEdit.var"#9#10"}}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#37#40", Array{Int64, 1}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Generator{Array{Int64, 1}, REPL.LineEdit.var"#37#40"}})
precompile(Tuple{Type{REPL.LineEdit.KeyAlias}, Any})
precompile(Tuple{typeof(REPL.LineEdit.normalize_key), Union{Base.SubString{String}, String}})
precompile(Tuple{Type{Pair{A, B} where B where A}, String, REPL.LineEdit.KeyAlias})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Pair{String, Nothing}, Vararg{Pair{A, B} where B where A}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Any, String})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#38#41", Base.UnitRange{Int64}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Generator{Base.UnitRange{Int64}, REPL.LineEdit.var"#38#41"}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#39#42", Base.UnitRange{Int64}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Generator{Base.UnitRange{Int64}, REPL.LineEdit.var"#39#42"}})
precompile(Tuple{typeof(Base.merge!), Base.Dict{Any, Any}, Base.Dict{Any, Any}, Vararg{Base.Dict{Any, Any}}})
precompile(Tuple{typeof(Base.hashindex), Char, Int64})
precompile(Tuple{typeof(Base.isequal), String, Char})
precompile(Tuple{Type{Pair{A, B} where B where A}, Char, Function})
precompile(Tuple{Type{Pair{A, B} where B where A}, String, Function})
precompile(Tuple{typeof(REPL.LineEdit.normalize_key), Char})
precompile(Tuple{Type{Pair{A, B} where B where A}, Char, REPL.LineEdit.KeyAlias})
precompile(Tuple{Type{Pair{A, B} where B where A}, Int64, REPL.LineEdit.KeyAlias})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Pair{Char, REPL.LineEdit.var"#114#170"}, Vararg{Pair{A, B} where B where A}})
precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Any, Int64})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Pair{String, REPL.LineEdit.var"#226#236"}, Vararg{Pair{A, B} where B where A}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Pair{String, REPL.LineEdit.var"#246#254"}, Vararg{Pair{A, B} where B where A}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#251#259", Base.UnitRange{Int64}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Generator{Base.UnitRange{Int64}, REPL.LineEdit.var"#251#259"}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#252#260", Base.UnitRange{Int64}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Generator{Base.UnitRange{Int64}, REPL.LineEdit.var"#252#260"}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.LineEdit.var"#253#261", Base.UnitRange{Int64}})
precompile(Tuple{Type{Base.Dict{Any, Any}}, Base.Generator{Base.UnitRange{Int64}, REPL.LineEdit.var"#253#261"}})
precompile(Tuple{typeof(Base.vect), Base.Dict{Any, Any}, Vararg{Base.Dict{Any, Any}}})
precompile(Tuple{Type{NamedTuple{(:override,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(REPL.LineEdit.keymap), Union{Array{Base.Dict{Any, Any}, 1}, Array{Base.Dict{Char, Any}, 1}}})
precompile(Tuple{typeof(Base.haskey), Base.Dict{Any, Any}, String})
precompile(Tuple{typeof(REPL.LineEdit.normalize_key), Union{Int64, UInt8}})
precompile(Tuple{typeof(Base.iterate), Array{Base.Dict{Any, Any}, 1}})
precompile(Tuple{typeof(Base.getindex), Base.Dict{Any, Any}, String})
precompile(Tuple{REPL.LineEdit.var"##add_nested_key!#26", Bool, typeof(REPL.LineEdit.add_nested_key!), Base.Dict{Char, Any}, Union{Char, String}, Any})
precompile(Tuple{typeof(Base.delete!), Base.Set{Any}, String})
precompile(Tuple{typeof(Base.iterate), Array{Base.Dict{Any, Any}, 1}, Int64})
precompile(Tuple{typeof(REPL.LineEdit.postprocess!), Any})
precompile(Tuple{typeof(Base.haskey), Base.Dict{Char, Any}, Char})
precompile(Tuple{typeof(REPL.LineEdit.fixup_keymaps!), Vararg{Any, 4}})
precompile(Tuple{typeof(Base.keys), Base.Dict{Char, Any}})
precompile(Tuple{typeof(Base.iterate), Base.KeySet{Char, Base.Dict{Char, Any}}})
precompile(Tuple{typeof(Base.iterate), Base.KeySet{Char, Base.Dict{Char, Any}}, Int64})
precompile(Tuple{typeof(Base.:(==)), Char, String})
precompile(Tuple{Type{REPL.REPLCompletions.REPLInterpreterCache}})
precompile(Tuple{typeof(Base.code_typed), Any, Any})
precompile(Tuple{typeof(Base.length), Array{Core.LineInfoNode, 1}})
precompile(Tuple{Type{Pair{A, B} where B where A}, Core.CodeInfo, Type})
precompile(Tuple{typeof(REPL.REPLCompletions.include), String})
precompile(Tuple{Type{Base.Dict{String, String}}, NTuple{2515, Pair{String, String}}})
precompile(Tuple{Type{Base.Dict{String, String}}, NTuple{27, Pair{String, String}}})
precompile(Tuple{Type{Base.Dict{String, String}}, NTuple{1185, Pair{String, String}}})
precompile(Tuple{Type{Base.Iterators.Filter{F, I} where I where F}, REPL.REPLCompletions.var"#26#28", Base.Dict{String, String}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.REPLCompletions.var"#25#27", Base.Iterators.Filter{REPL.REPLCompletions.var"#26#28", Base.Dict{String, String}}})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Base.Generator{Base.Iterators.Filter{REPL.REPLCompletions.var"#26#28", Base.Dict{String, String}}, REPL.REPLCompletions.var"#25#27"}})
precompile(Tuple{typeof(Base.keys), Base.Dict{Char, Char}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.REPLCompletions.var"#29#30", Base.KeySet{Char, Base.Dict{Char, Char}}})
precompile(Tuple{typeof(Base.join), Base.Generator{Base.KeySet{Char, Base.Dict{Char, Char}}, REPL.REPLCompletions.var"#29#30"}})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Generator{Base.KeySet{Char, Base.Dict{Char, Char}}, REPL.REPLCompletions.var"#29#30"}})
precompile(Tuple{typeof(Base.:(*)), String, String, String})
precompile(Tuple{Type{Base.Iterators.Filter{F, I} where I where F}, REPL.REPLCompletions.var"#32#34", Base.Dict{String, String}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.REPLCompletions.var"#31#33", Base.Iterators.Filter{REPL.REPLCompletions.var"#32#34", Base.Dict{String, String}}})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Base.Generator{Base.Iterators.Filter{REPL.REPLCompletions.var"#32#34", Base.Dict{String, String}}, REPL.REPLCompletions.var"#31#33"}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, REPL.REPLCompletions.var"#35#36", Base.KeySet{Char, Base.Dict{Char, Char}}})
precompile(Tuple{typeof(Base.join), Base.Generator{Base.KeySet{Char, Base.Dict{Char, Char}}, REPL.REPLCompletions.var"#35#36"}})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Generator{Base.KeySet{Char, Base.Dict{Char, Char}}, REPL.REPLCompletions.var"#35#36"}})
precompile(Tuple{typeof(REPL.TerminalMenus.include), String})
precompile(Tuple{Type{REPL.TerminalMenus.Key}, Int32})
precompile(Tuple{Type{Base.Dict{Symbol, Union{Bool, Char, String}}}})
precompile(Tuple{Type{NamedTuple{(:charset, :scroll, :supress_output, :ctrl_c_interrupt), T} where T<:Tuple}, Tuple{Symbol, Symbol, Bool, Bool}})
precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{10, Symbol}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:charset, :scroll, :supress_output, :ctrl_c_interrupt), Tuple{Symbol, Symbol, Bool, Bool}}, typeof(REPL.TerminalMenus.config)})
precompile(Tuple{Type{Ref{Any}}, Nothing})
precompile(Tuple{typeof(Markdown.mdexpr), String})
precompile(Tuple{typeof(Markdown.hashheader), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{Type{NamedTuple{(:eat,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Markdown.list), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{Type{NamedTuple{(:padding,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Markdown.fencedcode), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.blockquote), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{Type{NamedTuple{(:allow_whitespace, :allowempty, :eat), T} where T<:Tuple}, Tuple{Bool, Bool, Bool}})
precompile(Tuple{typeof(Markdown.admonition), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{Type{NamedTuple{(:rep,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Markdown.blocktex), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.blockinterp), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.indentcode), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.footnote), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.github_table), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.horizontalrule), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.setextheader), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Base.:(==)), Char, Char})
precompile(Tuple{Type{NamedTuple{(:breaking,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Markdown.paragraph), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.toexpr), Markdown.Paragraph})
precompile(Tuple{typeof(Markdown.toexpr), Array{Any, 1}})
precompile(Tuple{typeof(Markdown.toexpr), String})
precompile(Tuple{Type{Pair{A, B} where B where A}, String, Base.Regex})
precompile(Tuple{Type{Base.Dict{K, V} where V where K}, Pair{String, Base.Regex}, Vararg{Pair{String, Base.Regex}}})
precompile(Tuple{Type{Base.Dict{String, Base.Regex}}, NTuple{7, Pair{String, Base.Regex}}})
precompile(Tuple{typeof(Base.unescape_string), String, NTuple{5, Char}})
precompile(Tuple{typeof(Base.unescape_string), Base.GenericIOBuffer{Array{UInt8, 1}}, String, NTuple{5, Char}})
precompile(Tuple{Type{Array{UInt8, 1}}, String})
precompile(Tuple{typeof(Base.eachindex), String})
precompile(Tuple{typeof(Base.Iterators.zip), Base.EachStringIndex{String}, Vararg{Any}})
precompile(Tuple{Type{Base.Iterators.Zip{Is} where Is<:Tuple}, Tuple{Base.EachStringIndex{String}, String}})
precompile(Tuple{Base.Iterators.var"#5#6"{Tuple{Base.EachStringIndex{String}, String}}, Int64})
precompile(Tuple{Type{Base.Iterators.Stateful{T, VS, N} where N<:Integer where VS where T}, Base.Iterators.Zip{Tuple{Base.EachStringIndex{String}, String}}})
precompile(Tuple{typeof(Base.getindex), Type{Array{Tuple{Int64, Int64, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}}})
precompile(Tuple{typeof(Base.getindex), Type{Tuple{Base.UnitRange{Int64}, Union{Expr, Pair{Symbol, Any}, Symbol}}}})
precompile(Tuple{Type{Array{NamedTuple{(:message, :position, :hint), Tuple{Base.AnnotatedString{String}, Union{Nothing, Int64}, String}}, 1}}})
precompile(Tuple{Type{NamedTuple{(:content, :bytes, :s, :parts, :active_styles, :pending_styles, :offset, :point, :escape, :interpolated, :errors), T} where T<:Tuple}, Tuple{String, Array{UInt8, 1}, Base.Iterators.Stateful{Base.Iterators.Zip{Tuple{Base.EachStringIndex{String}, String}}, Union{Nothing, Tuple{Tuple{Int64, Char}, Tuple{Int64, Int64}}}, Int64}, Array{Any, 1}, Array{Array{Tuple{Int64, Int64, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}, 1}, Array{Tuple{Base.UnitRange{Int64}, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}, Base.RefValue{Int64}, Base.RefValue{Int64}, Base.RefValue{Bool}, Base.RefValue{Bool}, Array{NamedTuple{(:message, :position, :hint), Tuple{Base.AnnotatedString{String}, Union{Nothing, Int64}, String}}, 1}}})
precompile(Tuple{typeof(Base.isempty), Array{NamedTuple{(:message, :position, :hint), Tuple{Base.AnnotatedString{String}, Union{Nothing, Int64}, String}}, 1}})
precompile(Tuple{typeof(Base.getindex), Base.RefValue{Bool}})
precompile(Tuple{typeof(Base.map), Function, Array{Any, 1}})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(StyledStrings.eval), Array{Any, 1}})
precompile(Tuple{typeof(Base.collect_similar), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(StyledStrings.eval)}})
precompile(Tuple{typeof(Base.annotatedstring)})
precompile(Tuple{typeof(Base.:(|>)), Base.AnnotatedString{String}, typeof(Base.annotatedstring_optimize!)})
precompile(Tuple{typeof(Base.push!), Array{Char, 1}, Char})
precompile(Tuple{typeof(Base.setindex!), Array{Pair{Symbol, Any}, 1}, Pair{Symbol, Any}, Int64})
precompile(Tuple{typeof(Base.setindex!), Base.RefValue{Int64}, Int64})
precompile(Tuple{typeof(Base.:(!=)), Char, Char})
precompile(Tuple{Type{NamedTuple{(:slant,), T} where T<:Tuple}, Tuple{Symbol}})
precompile(Tuple{StyledStrings.var"#read_underline!#55"{StyledStrings.var"#nextnonwhitespace!#54"{StyledStrings.var"#skipwhitespace!#44"}, StyledStrings.var"#parsecolor#53"{NamedTuple{(:content, :bytes, :s, :parts, :active_styles, :pending_styles, :offset, :point, :escape, :interpolated, :errors), Tuple{String, Array{UInt8, 1}, Base.Iterators.Stateful{Base.Iterators.Zip{Tuple{Base.EachStringIndex{String}, String}}, Union{Nothing, Tuple{Tuple{Int64, Char}, Tuple{Int64, Int64}}}, Int64}, Array{Any, 1}, Array{Array{Tuple{Int64, Int64, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}, 1}, Array{Tuple{Base.UnitRange{Int64}, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}, Base.RefValue{Int64}, Base.RefValue{Int64}, Base.RefValue{Bool}, Base.RefValue{Bool}, Array{NamedTuple{(:message, :position, :hint), Tuple{Base.AnnotatedString{String}, Union{Nothing, Int64}, String}}, 1}}}, NTuple{18, String}}, StyledStrings.var"#readsymbol!#51", StyledStrings.var"#readalph!#49", StyledStrings.var"#skipwhitespace!#44", NTuple{5, String}}, NamedTuple{(:content, :bytes, :s, :parts, :active_styles, :pending_styles, :offset, :point, :escape, :interpolated, :errors), Tuple{String, Array{UInt8, 1}, Base.Iterators.Stateful{Base.Iterators.Zip{Tuple{Base.EachStringIndex{String}, String}}, Union{Nothing, Tuple{Tuple{Int64, Char}, Tuple{Int64, Int64}}}, Int64}, Array{Any, 1}, Array{Array{Tuple{Int64, Int64, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}, 1}, Array{Tuple{Base.UnitRange{Int64}, Union{Expr, Pair{Symbol, Any}, Symbol}}, 1}, Base.RefValue{Int64}, Base.RefValue{Int64}, Base.RefValue{Bool}, Base.RefValue{Bool}, Array{NamedTuple{(:message, :position, :hint), Tuple{Base.AnnotatedString{String}, Union{Nothing, Int64}, String}}, 1}}}, Char})
precompile(Tuple{Type{NamedTuple{(:underline,), T} where T<:Tuple}, Tuple{StyledStrings.SimpleColor}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:underline,), Tuple{StyledStrings.SimpleColor}}, Type{StyledStrings.Face}})
precompile(Tuple{typeof(Base.vect), Tuple{Base.UnitRange{Int64}, Pair{Symbol, Any}}, Vararg{Tuple{Base.UnitRange{Int64}, Pair{Symbol, Any}}}})
precompile(Tuple{Type{Base.AnnotatedString{S} where S<:AbstractString}, String, Array{Tuple{Base.UnitRange{Int64}, Pair{Symbol, Any}}, 1}})
precompile(Tuple{Type{Array{Base.AnnotatedString{String}, 1}}, UndefInitializer, Tuple{Int64}})
precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Base.AnnotatedString{String}, 1}, Base.AnnotatedString{String}, Base.Generator{Array{Any, 1}, typeof(StyledStrings.eval)}, Int64})
precompile(Tuple{typeof(Base.hash), String, UInt64})
precompile(Tuple{typeof(Base.setindex!), Base.RefValue{Module}, Module})
precompile(Tuple{typeof(REPL.REPLCompletions.__init__)})
precompile(Tuple{typeof(REPL.TerminalMenus.__init__)})
precompile(Tuple{typeof(REPL.__init__)})
precompile(Tuple{Base.var"#1069#1071"{Bool, Int64, Bool}, Module})
precompile(Tuple{Type{REPL.Terminals.TTYTerminal}, String, Base.TTY, Base.TTY, Base.TTY})
precompile(Tuple{typeof(Base.:(*)), Int64, Int64, Int64})
precompile(Tuple{Type{Base.UnitRange{T} where T<:Real}, Int64, Int64})
precompile(Tuple{typeof(Base.convert), Type{Tuple{Base.UnitRange{Int64}, Pair{Symbol, Any}}}, Tuple{Base.UnitRange{Int64}, Pair{Symbol, Any}}})
precompile(Tuple{typeof(Base.min), Int64, Int64})
precompile(Tuple{typeof(Base.split_sign), Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{UInt64, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{UInt64, Bool}, Int64, Int64})
precompile(Tuple{Type{NamedTuple{(:pad,), T} where T<:Tuple}, Tuple{Int64}})
precompile(Tuple{typeof(Base.abs), UInt64})
precompile(Tuple{typeof(Base.unsigned), UInt64})
precompile(Tuple{typeof(Base.top_set_bit), UInt64})
precompile(Tuple{Base.BottomRF{typeof(Base.:(+))}, Base._InitialValue, Int64})
precompile(Tuple{Type{UndefKeywordError}, Symbol})
precompile(Tuple{Base.var"##s1052#656", Vararg{Any, 4}})
precompile(Tuple{typeof(Base.string), Symbol, Int64})
precompile(Tuple{typeof(Base.Cartesian.lreplace!), Int64, Base.Cartesian.LReplace{String}})
precompile(Tuple{typeof(Base.Cartesian._nloops), Int64, Symbol, Expr, Expr, Vararg{Expr}})
precompile(Tuple{typeof(Base.:(==)), Expr, Int64})
precompile(Tuple{typeof(Base.get_chunks_id), Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, Int64}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.getproperty), Base.Generator{Tuple{}, typeof(Base.identity)}, Symbol})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Tuple{}, typeof(Base.identity)}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Tuple{}, typeof(Base.identity)}, Int64, Int64})
precompile(Tuple{typeof(Base.reduce_empty), Base.MappingRF{typeof(Base._str_sizehint), Base.BottomRF{typeof(Base.:(+))}}, Type{Base.AnnotatedString{String}}})
precompile(Tuple{typeof(Base.Broadcast.result_style), Nothing, Base.Broadcast.Style{Tuple}})
precompile(Tuple{typeof(Base.Broadcast.broadcastable), Tuple{Int64, Int64}})
precompile(Tuple{typeof(REPL.banner), IO, Int64})
precompile(Tuple{typeof(Base.mapreduce), Function, Function, Tuple{Base.AnnotatedString{String}, String, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, String}})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base._str_sizehint), typeof(Base.:(+)), Base._InitialValue, Tuple{Base.AnnotatedString{String}, String, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, String}})
precompile(Tuple{typeof(Base.mapreduce), Function, Function, Tuple{Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}}})
precompile(Tuple{typeof(Base.displaysize), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(>=)), Tuple{Int64, Int64}, Tuple{Int64, Int64}})
precompile(Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}})
precompile(Tuple{typeof(Base.copy), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}})
precompile(Tuple{typeof(Base.all), Tuple{Bool, Bool}})
precompile(Tuple{typeof(Base.mapreduce), Function, Function, NTuple{10, Base.AnnotatedString{String}}})
precompile(Tuple{typeof(Base.print), REPL.Terminals.TTYTerminal, Base.AnnotatedString{String}})
precompile(Tuple{Base.MappingRF{StyledStrings.var"#mergedface#6", Base.BottomRF{typeof(Base.merge)}}, StyledStrings.Face, Symbol})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Symbol, Nothing, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{Type{StyledStrings.Face}, String, Int64, Symbol, Symbol, StyledStrings.SimpleColor, StyledStrings.SimpleColor, StyledStrings.SimpleColor, Bool, Bool, Array{Symbol, 1}})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Nothing, Nothing, Nothing, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Symbol, Nothing, StyledStrings.SimpleColor, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Nothing, Symbol, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Symbol, Symbol, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Nothing, Array{Symbol, 1}})
precompile(Tuple{Base.MappingRF{StyledStrings.var"#mergedface#6", Base.BottomRF{typeof(Base.merge)}}, StyledStrings.Face, StyledStrings.Face})
precompile(Tuple{typeof(Base.getproperty), REPL.Terminals.TTYTerminal, Symbol})
precompile(Tuple{Type{REPL.LineEditREPL}, REPL.Terminals.TextTerminal, Bool, Bool})
precompile(Tuple{typeof(Base.setproperty!), REPL.Options, Symbol, Bool})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEditREPL, Symbol, Bool})
precompile(Tuple{Type{REPL.REPLDisplay{Repl} where Repl<:REPL.AbstractREPL}, REPL.LineEditREPL})
precompile(Tuple{typeof(Base.__atreplinit), REPL.LineEditREPL})
precompile(Tuple{typeof(REPL.run_repl), REPL.AbstractREPL, Any})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, typeof(REPL.start_repl_backend), REPL.REPLBackend, Any})
precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:get_module,), Tuple{REPL.var"#63#69"{REPL.LineEditREPL}}}, Type{NamedTuple{(:get_module,), T} where T<:Tuple}})
precompile(Tuple{Base.var"#1070#1072", REPL.REPLBackend})
precompile(Tuple{Type{REPL.LineEdit.Modifiers}, Bool})
precompile(Tuple{Type{NamedTuple{(:pass_empty, :suppress_on_semicolon), T} where T<:Tuple}, Tuple{Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:read, :write, :create), T} where T<:Tuple}, Tuple{Bool, Bool, Bool}})
precompile(Tuple{typeof(Base.getproperty), Pair{String, REPL.LineEdit.var"#50#81"}, Symbol})
precompile(Tuple{Type{REPL.LineEdit.InputAreaState}, Int64, Int64})
precompile(Tuple{REPL.var"#64#70"{REPL.LineEditREPL, REPL.REPLBackendRef}})
precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{12, Symbol}})
precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:prompt_prefix, :prompt_suffix, :repl, :complete, :on_enter), Tuple{String, typeof(Base.input_color), REPL.LineEditREPL, REPL.REPLCompletionProvider, typeof(REPL.return_callback)}}, Type{NamedTuple{(:prompt_prefix, :prompt_suffix, :output_prefix, :output_prefix_prefix, :output_prefix_suffix, :keymap_dict, :repl, :complete, :on_enter, :on_done, :hist, :sticky), T} where T<:Tuple}})
precompile(Tuple{Type{REPL.LineEdit.Prompt}, Union{Function, String}, Union{Function, String}, Union{Function, String}, Union{Function, String}, Union{Function, String}, Union{Function, String}, Base.Dict{Char, Any}, Union{Nothing, REPL.AbstractREPL}, REPL.LineEdit.CompletionProvider, Function, Function, REPL.LineEdit.HistoryProvider, Bool})
precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:prompt_prefix, :prompt_suffix, :repl, :complete, :on_done), Tuple{String, typeof(Base.input_color), REPL.LineEditREPL, REPL.REPLCompletionProvider, REPL.var"#do_respond#82"{Bool, Bool, REPL.var"#92#104"{REPL.LineEditREPL}, REPL.LineEditREPL, REPL.LineEdit.Prompt}}}, Type{NamedTuple{(:prompt_prefix, :prompt_suffix, :output_prefix, :output_prefix_prefix, :output_prefix_suffix, :keymap_dict, :repl, :complete, :on_enter, :on_done, :hist, :sticky), T} where T<:Tuple}})
precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:prompt_prefix, :prompt_suffix, :repl, :complete, :on_done, :sticky), Tuple{String, typeof(Base.input_color), REPL.LineEditREPL, REPL.ShellCompletionProvider, REPL.var"#do_respond#82"{Bool, Bool, REPL.var"#93#105"{REPL.LineEditREPL}, REPL.LineEditREPL, REPL.LineEdit.Prompt}, Bool}}, Type{NamedTuple{(:prompt_prefix, :prompt_suffix, :output_prefix, :output_prefix_prefix, :output_prefix_suffix, :keymap_dict, :repl, :complete, :on_enter, :on_done, :hist, :sticky), T} where T<:Tuple}})
precompile(Tuple{typeof(Base.convert), Type{Array{Symbol, 1}}, Array{UInt8, 1}})
precompile(Tuple{typeof(Base.prepend!), Array{Base.Dict{Any, Any}, 1}, Array{Base.Dict{Any, Any}, 1}})
precompile(Tuple{typeof(REPL.LineEdit.init_state), Any, REPL.LineEdit.Prompt})
precompile(Tuple{Type{REPL.LineEdit.PromptState}, REPL.Terminals.AbstractTerminal, REPL.LineEdit.Prompt, Base.GenericIOBuffer{Array{UInt8, 1}}, Symbol, Union{Nothing, String}, Array{Base.GenericIOBuffer{Array{UInt8, 1}}, 1}, Int64, REPL.LineEdit.InputAreaState, Int64, Base.Threads.SpinLock, Float64, Float64, Union{Nothing, Base.Timer}})
precompile(Tuple{typeof(REPL.LineEdit.init_state), Any, REPL.LineEdit.HistoryPrompt})
precompile(Tuple{typeof(REPL.LineEdit.init_state), Any, REPL.LineEdit.PrefixHistoryPrompt})
precompile(Tuple{typeof(REPL.LineEdit.run_interface), REPL.Terminals.TextTerminal, REPL.LineEdit.ModalInterface, REPL.LineEdit.MIState})
precompile(Tuple{typeof(Base.reseteof), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(REPL.Terminals.raw!), REPL.Terminals.TTYTerminal, Bool})
precompile(Tuple{typeof(REPL.Terminals.enable_bracketed_paste), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(REPL.LineEdit.activate), REPL.LineEdit.ModalInterface, REPL.LineEdit.MIState, REPL.Terminals.AbstractTerminal, REPL.Terminals.TextTerminal})
precompile(Tuple{typeof(REPL.LineEdit.activate), REPL.LineEdit.TextInterface, REPL.LineEdit.MIState, REPL.Terminals.AbstractTerminal, REPL.Terminals.TextTerminal})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PromptState, Symbol, REPL.LineEdit.InputAreaState})
precompile(Tuple{typeof(REPL.LineEdit.refresh_line), Union{Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.LineEdit.MIState, REPL.LineEdit.ModeState}, REPL.Terminals.AbstractTerminal})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.UnixTerminal, Any})
precompile(Tuple{REPL.LineEdit.var"##refresh_multi_line#17", Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.UnixTerminal, Any})
precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{Base.ExtremaMap{typeof(Base.identity)}, Base.BottomRF{typeof(Base._extrema_rf)}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{typeof(Base._extrema_rf)}, Symbol})
precompile(Tuple{typeof(Base.iszero), Float64})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.Terminals.UnixTerminal, Union{REPL.LineEdit.PrefixSearchState, REPL.LineEdit.PromptState}})
precompile(Tuple{typeof(REPL.Terminals.clear_line), REPL.Terminals.TerminalBuffer})
precompile(Tuple{typeof(REPL.Terminals.width), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(REPL.Terminals.height), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(REPL.Terminals.hascolor), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(REPL.LineEdit.write_prompt), REPL.Terminals.AbstractTerminal, REPL.LineEdit.PromptState, Bool})
precompile(Tuple{typeof(Base.input_color)})
precompile(Tuple{typeof(Base.write), REPL.Terminals.TerminalBuffer, String})
precompile(Tuple{typeof(REPL.LineEdit.write_prompt), IO, Union{AbstractString, Function}, Bool})
precompile(Tuple{REPL.var"#89#90"{REPL.LineEditREPL, String}})
precompile(Tuple{typeof(Base.write), REPL.Terminals.TTYTerminal, Array{UInt8, 1}})
precompile(Tuple{typeof(REPL.LineEdit.keymap), REPL.LineEdit.PromptState, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(REPL.LineEdit.match_input), Base.Dict{Char, V} where V, Union{Nothing, REPL.LineEdit.MIState}})
precompile(Tuple{typeof(REPL.LineEdit.terminal), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.match_input), Base.Dict{Char, V} where V, Union{Nothing, REPL.LineEdit.MIState}, Union{Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.Terminals.AbstractTerminal}, Array{Char, 1}})
precompile(Tuple{typeof(REPL.LineEdit.match_input), Base.Dict{Char, V} where V, Union{Nothing, REPL.LineEdit.MIState}, Union{Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.Terminals.AbstractTerminal}, Array{Char, 1}, Base.Dict{Char, V} where V})
precompile(Tuple{typeof(Base.eof), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(Base.eof), Base.TTY})
precompile(Tuple{Base.var"#readcb_specialized#778", Base.TTY, Int64, UInt64})
precompile(Tuple{typeof(Base.read), REPL.Terminals.TTYTerminal, Type{Char}})
precompile(Tuple{typeof(Base.read), Base.TTY, Type{UInt8}})
precompile(Tuple{typeof(Base.get), Base.Dict{Char, Any}, Char, Nothing})
precompile(Tuple{typeof(REPL.LineEdit.match_input), Function, Union{Nothing, REPL.LineEdit.MIState}, Any, Array{Char, 1}, Any})
precompile(Tuple{typeof(REPL.LineEdit.keymap_data), REPL.LineEdit.PromptState, REPL.LineEdit.Prompt})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#139#195", String}, Any, Any})
precompile(Tuple{typeof(Base.isempty), Nothing})
precompile(Tuple{typeof(Base.isequal), UInt8})
precompile(Tuple{REPL.LineEdit.var"#139#195", REPL.LineEdit.MIState, Any, Union{Char, Base.SubString{String}, String}})
precompile(Tuple{typeof(REPL.LineEdit.edit_insert), REPL.LineEdit.MIState, Any})
precompile(Tuple{typeof(REPL.LineEdit.region_active), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.activate_region), REPL.LineEdit.PromptState, Symbol})
precompile(Tuple{typeof(Base.write), REPL.Terminals.TTYTerminal, String})
precompile(Tuple{typeof(REPL.LineEdit._buffer), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(Base.getproperty), REPL.LineEdit.TextInterface, Symbol})
precompile(Tuple{Type{NamedTuple{(:raise, :depwarn), T} where T<:Tuple}, Tuple{Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:aggressive_constant_propagation, :unoptimize_throw_blocks), T} where T<:Tuple}, Tuple{Bool, Bool}})
precompile(Tuple{typeof(Core.Compiler.sym_in), Symbol, NTuple{10, Symbol}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:aggressive_constant_propagation, :unoptimize_throw_blocks), Tuple{Bool, Bool}}, Type{Core.Compiler.InferenceParams}})
precompile(Tuple{Base.var"##s129#249", Vararg{Any, 5}})
precompile(Tuple{typeof(Base._nt_names), Type{NamedTuple{(:scratch,), Tuple{Array{Symbol, 1}}}}})
precompile(Tuple{Type{NamedTuple{(:all, :imported), T} where T<:Tuple}, Tuple{Bool, Bool}})
precompile(Tuple{Type{NamedTuple{(:c_start, :c_end), T} where T<:Tuple}, Tuple{Char, Char}})
precompile(Tuple{typeof(Base.in), Array{Char, 1}})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Nothing, Nothing}, Int64})
precompile(Tuple{typeof(Base.keys), Base.Dict{String, String}})
precompile(Tuple{Type{NamedTuple{(:raise,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Base.getproperty), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}}}, Symbol})
precompile(Tuple{typeof(Base._nt_names), Type{NamedTuple{(:scratch,), Tuple{Array{REPL.REPLCompletions.Completion, 1}}}}})
precompile(Tuple{Type{NamedTuple{(:shell_escape,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{Type{NamedTuple{(:join, :sort), T} where T<:Tuple}, Tuple{Bool, Bool}})
precompile(Tuple{typeof(Base.getproperty), Base.Order.By{REPL.REPLCompletions.var"#47#50", Base.Order.ForwardOrdering}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{REPL.REPLCompletions.var"#47#50", Base.Order.ForwardOrdering}}}, Symbol})
precompile(Tuple{Type{NamedTuple{(:string_escape,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Base.getproperty), Base.Order.By{REPL.REPLCompletions.var"#48#51", Base.Order.ForwardOrdering}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{REPL.REPLCompletions.var"#48#51", Base.Order.ForwardOrdering}}}, Symbol})
precompile(Tuple{typeof(REPL.LineEdit.complete_line), REPL.REPLCompletionProvider, REPL.LineEdit.PromptState, Module})
precompile(Tuple{typeof(Base.incomplete_tag), Nothing})
precompile(Tuple{typeof(Base.filter!), REPL.REPLCompletions.var"#11#12"{Base.Returns{Bool}, Module, Symbol}, Array{Symbol, 1}})
precompile(Tuple{REPL.REPLCompletions.var"#3#8", Base.GenericIOBuffer{Array{UInt8, 1}}, Symbol})
precompile(Tuple{typeof(Base.in!), REPL.REPLCompletions.ModuleCompletion, Base.Set{REPL.REPLCompletions.Completion}})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.ModuleCompletion, REPL.REPLCompletions.ModuleCompletion})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}}}, REPL.REPLCompletions.ModuleCompletion, REPL.REPLCompletions.ModuleCompletion})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.ModuleCompletion})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PromptState, Symbol, String})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.LineEdit.PromptState})
precompile(Tuple{REPL.LineEdit.var"##refresh_multi_line#12", Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(REPL.LineEdit.refresh_multi_line), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:color,), Tuple{Symbol}}, typeof(Base.printstyled), REPL.Terminals.TTYTerminal, String})
precompile(Tuple{typeof(REPL.Terminals.cmove_left), REPL.Terminals.TTYTerminal, Int64})
precompile(Tuple{typeof(Base.print), REPL.Terminals.TTYTerminal, String})
precompile(Tuple{typeof(Core.Compiler.typeinf), REPL.REPLCompletions.REPLInterpreter, Core.Compiler.InferenceState})
precompile(Tuple{typeof(Core.Compiler.finish), Core.Compiler.InferenceState, REPL.REPLCompletions.REPLInterpreter})
precompile(Tuple{typeof(Core.Compiler.finish!), REPL.REPLCompletions.REPLInterpreter, Core.Compiler.InferenceResult})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.KeyvalCompletion, REPL.REPLCompletions.ModuleCompletion})
precompile(Tuple{typeof(REPL.LineEdit.match_input), REPL.LineEdit.KeyAlias, Union{Nothing, REPL.LineEdit.MIState}, Any, Any, Base.Dict{Char, V} where V})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#116#172", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#116#172", REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{Type{NamedTuple{(:depwarn,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{Type{Pair{A, B} where B where A}, Base.ScopedValues.ScopedValue{Base.CoreLogging.LogState}, Base.CoreLogging.LogState})
precompile(Tuple{typeof(Base.iterate), Pair{Base.ScopedValues.ScopedValue{Base.CoreLogging.LogState}, Base.CoreLogging.LogState}})
precompile(Tuple{typeof(Base.iterate), Pair{Base.ScopedValues.ScopedValue{Base.CoreLogging.LogState}, Base.CoreLogging.LogState}, Int64})
precompile(Tuple{typeof(Base.convert), Type{Base.CoreLogging.LogState}, Base.CoreLogging.LogState})
precompile(Tuple{typeof(REPL.return_callback), Any})
precompile(Tuple{typeof(Base.println), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(Base.convert), Type{Int32}, Int32})
precompile(Tuple{typeof(REPL.LineEdit.add_history), REPL.REPLHistoryProvider, REPL.LineEdit.PromptState})
precompile(Tuple{typeof(Base.iterate), Base.Dict{Symbol, REPL.LineEdit.Prompt}})
precompile(Tuple{typeof(Base.indexed_iterate), Pair{Symbol, REPL.LineEdit.Prompt}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Pair{Symbol, REPL.LineEdit.Prompt}, Int64, Int64})
precompile(Tuple{typeof(Base.isequal), REPL.LineEdit.Prompt, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(Base.iterate), Base.Dict{Symbol, REPL.LineEdit.Prompt}, Int64})
precompile(Tuple{typeof(Base.print), Base.IOStream, String})
precompile(Tuple{typeof(Base.flush), Base.IOStream})
precompile(Tuple{typeof(REPL.Terminals.disable_bracketed_paste), REPL.Terminals.TTYTerminal})
precompile(Tuple{typeof(REPL.LineEdit.mode), REPL.LineEdit.PromptState})
precompile(Tuple{REPL.var"#do_respond#82"{Bool, Bool, REPL.var"#95#107"{REPL.LineEditREPL, REPL.REPLHistoryProvider}, REPL.LineEditREPL, REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Bool})
precompile(Tuple{REPL.var"#95#107"{REPL.LineEditREPL, REPL.REPLHistoryProvider}, Any})
precompile(Tuple{typeof(Base.put!), Base.Channel{Any}, Tuple{Expr, Int64}})
precompile(Tuple{REPL.var"#63#69"{REPL.LineEditREPL}})
precompile(Tuple{typeof(REPL.softscope), Any})
precompile(Tuple{typeof(Base.getindex), Pair{Any, Bool}, Int64})
precompile(Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.TTY, Pair{Symbol, Array{Tuple{String, Int64}, 1}}})
precompile(Tuple{REPL.var"#59#60"{REPL.LineEditREPL, Pair{Any, Bool}, Bool, Bool}, Any})
precompile(Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.IOContext{Base.TTY}, Pair{Symbol, Module}})
precompile(Tuple{typeof(REPL.print_response), IO, Any, Bool, Bool, Union{Nothing, Base.Multimedia.AbstractDisplay}})
precompile(Tuple{typeof(Base.indexed_iterate), Pair{Any, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Pair{Any, Bool}, Int64, Int64})
precompile(Tuple{typeof(REPL.LineEdit.reset_state), REPL.LineEdit.PrefixSearchState})
precompile(Tuple{typeof(REPL.LineEdit.reset_state), REPL.REPLHistoryProvider})
precompile(Tuple{typeof(Base.in), Symbol, Tuple{Symbol, Symbol, Symbol}})
precompile(Tuple{typeof(REPL.LineEdit.reset_state), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.reset_state), REPL.LineEdit.SearchState})
precompile(Tuple{typeof(REPL.LineEdit.clear_input_area), REPL.Terminals.AbstractTerminal, REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.state), REPL.LineEdit.MIState, REPL.LineEdit.TextInterface})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.LineEdit.ModeState})
precompile(Tuple{REPL.LineEdit.var"##refresh_multi_line#14", Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.LineEdit.ModeState})
precompile(Tuple{typeof(Base.incomplete_tag), Int64})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:fgcolor, :href), Tuple{Symbol, String}}, typeof(Base.JuliaSyntax._printstyled), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Generator{Base.SubString{String}, Base.JuliaSyntax.var"#14#16"}})
precompile(Tuple{typeof(Base.repeat), Char, Int64})
precompile(Tuple{typeof(Base.incomplete_tag), Expr})
precompile(Tuple{typeof(Base.incomplete_tag), Base.Meta.ParseError})
precompile(Tuple{typeof(Base.incomplete_tag), Base.JuliaSyntax.ParseError})
precompile(Tuple{Type{Base.Multimedia.MIME{mime} where mime}, String})
precompile(Tuple{typeof(Base.Multimedia.display), Any})
precompile(Tuple{REPL.var"#57#58"{REPL.REPLDisplay{REPL.LineEditREPL}, Base.Multimedia.MIME{Symbol("text/plain")}, Base.RefValue{Any}}, Any})
precompile(Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.IOContext{Base.TTY}, Pair{Symbol, Bool}, Pair{Symbol, Module}})
precompile(Tuple{typeof(Base.print), Base.IOContext{Base.TTY}, String})
precompile(Tuple{typeof(Base.write), Base.IOContext{Base.TTY}, String})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Base.IOContext{Base.TTY}}}, typeof(Base.foldl), Type, Base.Dict{Symbol, Any}})
precompile(Tuple{Base.var"##mapfoldl#306", Base.IOContext{Base.TTY}, typeof(Base.mapfoldl), Function, Type, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.IOContext{Base.TTY}, Base.Dict{Symbol, Any}})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.TTY}, Base.Multimedia.MIME{Symbol("text/plain")}, Int64})
precompile(Tuple{typeof(Base.println), Base.IOContext{Base.TTY}})
precompile(Tuple{typeof(Base.incomplete_tag), Symbol})
precompile(Tuple{typeof(Base.in!), REPL.REPLCompletions.KeywordCompletion, Base.Set{REPL.REPLCompletions.Completion}})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.ModuleCompletion, REPL.REPLCompletions.KeywordCompletion})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}}}, REPL.REPLCompletions.ModuleCompletion, REPL.REPLCompletions.KeywordCompletion})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.KeywordCompletion})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.MethodCompletion})
precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Method})
precompile(Tuple{typeof(Base.string_with_env), Base.ImmutableDict{Symbol, Any}, Type})
precompile(Tuple{typeof(REPL.active_module)})
precompile(Tuple{typeof(REPL.active_module), REPL.LineEditREPL})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:context,), Tuple{Base.ImmutableDict{Symbol, Any}}}, typeof(Base.sprint), Function, Type, Vararg{Any}})
precompile(Tuple{Base.var"##sprint#539", Base.ImmutableDict{Symbol, Any}, Int64, typeof(Base.sprint), Function, Type, Vararg{Any}})
precompile(Tuple{typeof(Base.show_signature_function), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Any, Bool, String, Bool})
precompile(Tuple{Type{Pair{A, B} where B where A}, Symbol, TypeVar})
precompile(Tuple{Base.var"#547#548"{Tuple{}, String, Tuple{Char, Char}}, Base.GenericIOBuffer{Array{UInt8, 1}}})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.PathCompletion})
precompile(Tuple{typeof(Base.printstyled), String, String})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:bold, :italic, :underline, :blink, :reverse, :hidden, :color), Tuple{Bool, Bool, Bool, Bool, Bool, Bool, Symbol}}, typeof(Base.printstyled), Base.TTY, String, Vararg{String}})
precompile(Tuple{Base.var"##printstyled#1051", Bool, Bool, Bool, Bool, Bool, Bool, Symbol, typeof(Base.printstyled), Base.TTY, String, Vararg{String}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:bold, :italic, :underline, :blink, :reverse, :hidden), NTuple{6, Bool}}, typeof(Base.with_output_color), Function, Symbol, Base.TTY, String, Vararg{String}})
precompile(Tuple{Base.var"##with_output_color#1050", Bool, Bool, Bool, Bool, Bool, Bool, typeof(Base.with_output_color), Function, Symbol, Base.TTY, String, Vararg{String}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.var"#100#112"{REPL.LineEditREPL}, String}, Any, Any})
precompile(Tuple{REPL.var"#100#112"{REPL.LineEditREPL}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(Base.isempty), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(Base.getindex), Pair{Symbol, DataType}, Int64})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.TTY}, Base.Multimedia.MIME{Symbol("text/plain")}, Array{Int64, 1}})
precompile(Tuple{typeof(Base.isassigned), Array{Int64, 1}, Int64, Int64})
precompile(Tuple{typeof(Base.getindex), Array{Int64, 1}, Int64, Int64})
precompile(Tuple{typeof(Base.getindex), Pair{Symbol, Bool}, Int64})
precompile(Tuple{typeof(Base.alignment), Base.IOContext{Base.TTY}, Int64})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Int64})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String, Int64})
precompile(Tuple{typeof(Base.replace_in_print_matrix), Array{Int64, 1}, Int64, Int64, String})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.var"#96#108"{REPL.LineEdit.Prompt}, String}, Any, Any})
precompile(Tuple{REPL.var"#96#108"{REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(Base.hvcat), Tuple{Int64, Int64}, Int64, Vararg{Int64}})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Int64, Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.Broadcast.materialize), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.length), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base.range), Int64, Int64})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.TTY}, Base.Multimedia.MIME{Symbol("text/plain")}, Array{Int64, 2}})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String, String}, Char})
precompile(Tuple{typeof(Base.isassigned), Array{Int64, 2}, Int64, Int64})
precompile(Tuple{typeof(Base.replace_in_print_matrix), Array{Int64, 2}, Int64, Int64, String})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.KeywordCompletion, REPL.REPLCompletions.KeywordCompletion})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}}}, REPL.REPLCompletions.KeywordCompletion, REPL.REPLCompletions.KeywordCompletion})
precompile(Tuple{typeof(Base.filter!), REPL.REPLCompletions.var"#11#12"{REPL.REPLCompletions.var"#49#52", Module, Symbol}, Array{Symbol, 1}})
precompile(Tuple{typeof(Base.in!), REPL.REPLCompletions.PackageCompletion, Base.Set{REPL.REPLCompletions.Completion}})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.PackageCompletion, REPL.REPLCompletions.PackageCompletion})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.ModuleCompletion, REPL.REPLCompletions.PackageCompletion})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}}}, REPL.REPLCompletions.PackageCompletion, REPL.REPLCompletions.PackageCompletion})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.PackageCompletion})
precompile(Tuple{typeof(Base.in!), REPL.REPLCompletions.KeyvalCompletion, Base.Set{REPL.REPLCompletions.Completion}})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.KeyvalCompletion, REPL.REPLCompletions.KeywordCompletion})
precompile(Tuple{typeof(Base.Order.lt), Base.Order.By{typeof(REPL.REPLCompletions.completion_text), Base.Order.ForwardOrdering}, REPL.REPLCompletions.ModuleCompletion, REPL.REPLCompletions.KeyvalCompletion})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.KeyvalCompletion})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.TTY}, Base.Multimedia.MIME{Symbol("text/plain")}, Function})
precompile(Tuple{typeof(Base.getproperty), Core.MethodTable, Symbol})
precompile(Tuple{typeof(Base.startswith), String, Char})
precompile(Tuple{typeof(Base.gc_num)})
precompile(Tuple{typeof(Base.cumulative_compile_timing), Bool})
precompile(Tuple{typeof(Base.cumulative_compile_time_ns)})
precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}})
precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(-)), Tuple{Tuple{UInt64, UInt64}, Tuple{UInt64, UInt64}}}})
precompile(Tuple{Type{Base.GC_Diff}, Base.GC_Num, Base.GC_Num})
precompile(Tuple{typeof(Base.gc_alloc_count), Base.GC_Diff})
precompile(Tuple{typeof(Base.first), Tuple{UInt64, UInt64}})
precompile(Tuple{typeof(Base.last), Tuple{UInt64, UInt64}})
precompile(Tuple{Type{NamedTuple{(:msg,), T} where T<:Tuple}, Tuple{Nothing}})
precompile(Tuple{typeof(Base.getproperty), Base.GC_Diff, Symbol})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:msg,), Tuple{Nothing}}, typeof(Base.time_print), Base.TTY, UInt64, Int64, Int64, Int64, UInt64, UInt64, Bool})
precompile(Tuple{Base.var"#1043#1044"{Nothing, UInt64, Int64, Int64, UInt64, UInt64, Bool, String}, Base.GenericIOBuffer{Array{UInt8, 1}}})
precompile(Tuple{typeof(Base.prettyprint_getunits), Int64, Int64, Int64})
precompile(Tuple{Type{Int64}, Float64})
precompile(Tuple{typeof(Base.:(==)), Float64, Int64})
precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Array{UInt8, 1}}, Int64, String, Vararg{String}})
precompile(Tuple{REPL.var"#97#109"{REPL.LineEdit.MIState, Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.LineEdit.Prompt}})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PromptState, Symbol, Base.GenericIOBuffer{Array{UInt8, 1}}})
precompile(Tuple{typeof(REPL.LineEdit.complete_line), REPL.LineEdit.CompletionProvider, Any, Module})
precompile(Tuple{typeof(REPL.LineEdit.complete_line), REPL.ShellCompletionProvider, REPL.LineEdit.PromptState})
precompile(Tuple{typeof(Base.:(!=)), Base.SubString{String}, String})
precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Array{Any, 1}})
precompile(Tuple{typeof(Base.show), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.SubString{String}})
precompile(Tuple{typeof(REPL.LineEdit.default_enter_cb), Any})
precompile(Tuple{REPL.var"#do_respond#82"{Bool, Bool, REPL.var"#93#105"{REPL.LineEditREPL}, REPL.LineEditREPL, REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Bool})
precompile(Tuple{REPL.var"#93#105"{REPL.LineEditREPL}, Any})
precompile(Tuple{typeof(Base.cmd_gen), Tuple{Tuple{Base.SubString{String}}}})
precompile(Tuple{Type{Base.DimensionMismatch}, String})
precompile(Tuple{typeof(Core.Compiler.eltype), Type{Array{String, 1}}})
precompile(Tuple{Type{NamedTuple{(:ignorestatus,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Base.:(&)), UInt32, UInt8})
precompile(Tuple{typeof(Base.:(!=)), Int64, UInt32})
precompile(Tuple{typeof(Base.:(*)), Bool, UInt8})
precompile(Tuple{typeof(Base.:(|)), UInt8, UInt8})
precompile(Tuple{typeof(Base.repl_cmd), Base.Cmd, Base.TTY})
precompile(Tuple{typeof(Base.string), Base.SubString{String}})
precompile(Tuple{typeof(Base.shell_escape_posixly), String})
precompile(Tuple{typeof(Base.print_shell_escaped_posixly), Base.GenericIOBuffer{Array{UInt8, 1}}, String})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.var"#85#88"{REPL.LineEdit.Prompt}, String}, Any, Any})
precompile(Tuple{REPL.var"#85#88"{REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#79#110"{REPL.LineEdit.HistoryPrompt}, String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#79#110"{REPL.LineEdit.HistoryPrompt}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(Base.setproperty!), REPL.REPLHistoryProvider, Symbol, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(Base.setproperty!), REPL.REPLHistoryProvider, Symbol, Base.GenericIOBuffer{Array{UInt8, 1}}})
precompile(Tuple{REPL.LineEdit.var"#46#47"{REPL.LineEdit.MIState, REPL.LineEdit.HistoryPrompt, Bool, REPL.LineEdit.Prompt, Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.SearchState, Symbol, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.SearchState, Symbol, Bool})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.SearchState, Symbol, REPL.LineEdit.InputAreaState})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.LineEdit.SearchState})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.Terminals.UnixTerminal, Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.LineEdit.InputAreaState, Any})
precompile(Tuple{typeof(REPL.LineEdit.keymap), Any, Union{REPL.LineEdit.HistoryPrompt, REPL.LineEdit.PrefixHistoryPrompt}})
precompile(Tuple{typeof(REPL.LineEdit.terminal), REPL.LineEdit.SearchState})
precompile(Tuple{typeof(REPL.LineEdit.keymap_data), Any, Union{REPL.LineEdit.HistoryPrompt, REPL.LineEdit.PrefixHistoryPrompt}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#58#89", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#58#89", REPL.LineEdit.MIState, REPL.LineEdit.ModeState, Any})
precompile(Tuple{typeof(REPL.LineEdit.edit_clear), Base.GenericIOBuffer{Array{UInt8, 1}}})
precompile(Tuple{typeof(REPL.LineEdit.history_search), REPL.REPLHistoryProvider, Base.GenericIOBuffer{Array{UInt8, 1}}, Base.GenericIOBuffer{Array{UInt8, 1}}, Bool, Bool})
precompile(Tuple{REPL.LineEdit.var"##refresh_multi_line#13", Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(REPL.LineEdit.refresh_multi_line), REPL.LineEdit.ModeState})
precompile(Tuple{typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, Any, REPL.LineEdit.ModeState})
precompile(Tuple{REPL.LineEdit.var"##refresh_multi_line#15", Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, Any, REPL.LineEdit.ModeState})
precompile(Tuple{typeof(REPL.LineEdit.cancel_beep), REPL.LineEdit.ModeState})
precompile(Tuple{typeof(REPL.LineEdit.clear_input_area), REPL.Terminals.AbstractTerminal, REPL.LineEdit.ModeState})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.var"#98#110"{REPL.LineEdit.Prompt}, String}, Any, Any})
precompile(Tuple{REPL.var"#98#110"{REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{REPL.var"#99#111"{REPL.LineEdit.MIState, Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.LineEdit.Prompt}})
precompile(Tuple{REPL.var"#do_respond#82"{Bool, Bool, REPL.var"#92#104"{REPL.LineEditREPL}, REPL.LineEditREPL, REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Bool})
precompile(Tuple{REPL.var"#92#104"{REPL.LineEditREPL}, String})
precompile(Tuple{typeof(REPL.helpmode), Base.TTY, String, Module})
precompile(Tuple{Base.JuliaSyntax.var"#invoke_fixedworld#122"{Base.JuliaSyntax.var"#invoke_fixedworld#119#123"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}}, Base.SubString{String}, Vararg{Any}})
precompile(Tuple{Base.JuliaSyntax.var"#invoke_fixedworld#119#123"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Base.JuliaSyntax.var"#invoke_fixedworld#122"{Base.JuliaSyntax.var"#invoke_fixedworld#119#123"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}}, Base.SubString{String}, Vararg{Any}})
precompile(Tuple{typeof(Base.JuliaSyntax.core_parser_hook), Base.SubString{String}, String, Int64, Int64, Symbol})
precompile(Tuple{Type{NamedTuple{(:brief, :mod, :internal_accesses), T} where T<:Tuple}, Tuple{Bool, Module, Base.Set{Pair{Module, Symbol}}}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:brief, :mod, :internal_accesses), Tuple{Bool, Module, Base.Set{Pair{Module, Symbol}}}}, typeof(REPL.repl), Base.TTY, Symbol})
precompile(Tuple{typeof(Base.Docs.docm), LineNumberNode, Module, Any})
precompile(Tuple{typeof(REPL.lookup_doc), Symbol})
precompile(Tuple{typeof(Base.any), Function, Tuple{DataType, DataType, DataType}})
precompile(Tuple{typeof(REPL.log_nonpublic_access), Expr, Module, Base.Set{Pair{Module, Symbol}}})
precompile(Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Int64})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Type{typeof(Base.Docs.doc)}})
precompile(Tuple{typeof(Base.setindex!), Array{typeof(Base.Docs.doc), 1}, Function, Int64})
precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{typeof(Base.Docs.doc), 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Type{Module}})
precompile(Tuple{typeof(Base.setindex!), Array{Module, 1}, Module, Int64})
precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{Module, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Type{Any}})
precompile(Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Array{Any, 1}, Array{Module, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, QuoteNode, Int64, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Array{Any, 1}, Array{typeof(Base.Docs.doc), 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Expr, Int64, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Type{Expr}})
precompile(Tuple{typeof(Base.setindex!), Array{Expr, 1}, Expr, Int64})
precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{Expr, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(REPL.log_nonpublic_access), Tuple{Base.Broadcast.Extruded{Array{Any, 1}, Tuple{Bool}, Tuple{Int64}}, Tuple{Module}, Tuple{Base.Set{Pair{Module, Symbol}}}}}, Base.OneTo{Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.Iterators.flatten), Tuple{Base.Dict{String, String}, Base.Dict{String, String}}})
precompile(Tuple{Type{Base.Iterators.Flatten{I} where I}, Tuple{Base.Dict{String, String}, Base.Dict{String, String}}})
precompile(Tuple{typeof(Base.getproperty), Base.Iterators.Flatten{Tuple{Base.Dict{String, String}, Base.Dict{String, String}}}, Symbol})
precompile(Tuple{typeof(Base.isempty), Base.UnitRange{Int64}})
precompile(Tuple{typeof(REPL.repl_latex), Base.TTY, String})
precompile(Tuple{typeof(Base.keys), Base.Dict{Symbol, Base.Docs.DocStr}})
precompile(Tuple{typeof(Base.getproperty), Base.KeySet{Symbol, Base.Dict{Symbol, Base.Docs.DocStr}}, Symbol})
precompile(Tuple{typeof(Core.Compiler.arrayref_tfunc), Core.Compiler.InferenceLattice{Core.Compiler.PartialsLattice{Core.Compiler.ConstsLattice}}, Any, Any, Any})
precompile(Tuple{typeof(Base.argtail), Function})
precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(Base.identity), Int64})
precompile(Tuple{Type{NamedTuple{(:acronym,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Base.ismalformed), Char})
precompile(Tuple{typeof(Base.:(<=)), UInt32, UInt32})
precompile(Tuple{typeof(REPL.repl_search), Base.TTY, String, Module})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.names), Array{Any, 1}})
precompile(Tuple{typeof(Base.collect_similar), Array{Any, 1}, Base.Generator{Array{Any, 1}, typeof(Base.names)}})
precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{typeof(Base.GMP.MPZ.add!)}, Symbol})
precompile(Tuple{typeof(Base.typed_vcat), Type{Symbol}, Array{Symbol, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Vararg{Array{Symbol, 1}}})
precompile(Tuple{typeof(Base._typed_vcat), Type{Symbol}, NTuple{5, Array{Symbol, 1}}})
precompile(Tuple{typeof(Base.:(|>)), Array{Symbol, 1}, typeof(Base.unique)})
precompile(Tuple{typeof(Base.:(|>)), Array{Symbol, 1}, typeof(REPL.filtervalid)})
precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Char})
precompile(Tuple{REPL.Logged{DataType}, Module, Symbol})
precompile(Tuple{typeof(Base.Docs.doc), Base.Docs.Binding})
precompile(Tuple{typeof(Base.push!), Array{Base.Docs.MultiDoc, 1}, Base.Docs.MultiDoc})
precompile(Tuple{typeof(Base.iterate), Array{Type, 1}})
precompile(Tuple{typeof(Base.getindex), Base.IdDict{Any, Any}, Any})
precompile(Tuple{typeof(Base.push!), Array{Base.Docs.DocStr, 1}, Base.Docs.DocStr})
precompile(Tuple{typeof(Base.iterate), Array{Type, 1}, Int64})
precompile(Tuple{typeof(Base.map!), typeof(Base.Docs.parsedoc), Array{Any, 1}, Array{Base.Docs.DocStr, 1}})
precompile(Tuple{typeof(Base.Docs.formatdoc), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Docs.DocStr, String})
precompile(Tuple{typeof(Markdown.en_dash), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Markdown.inline_code), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{Type{Markdown.Footnote}, Nothing, Nothing})
precompile(Tuple{typeof(Markdown.footnote_link), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{Type{NamedTuple{(:match,), T} where T<:Tuple}, Tuple{Char}})
precompile(Tuple{typeof(Markdown.link), Base.GenericIOBuffer{Array{UInt8, 1}}, Markdown.MD})
precompile(Tuple{typeof(Base.Docs.formatdoc), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.Docs.DocStr, Type})
precompile(Tuple{typeof(Base.Docs.catdoc), Markdown.MD, Vararg{Markdown.MD}})
precompile(Tuple{Type{Markdown.MD}, Markdown.MD, Vararg{Markdown.MD}})
precompile(Tuple{typeof(Base.vcat), Markdown.MD, Markdown.MD, Markdown.MD})
precompile(Tuple{typeof(REPL.trimdocs), Markdown.MD, Bool})
precompile(Tuple{typeof(REPL._trimdocs), Markdown.Code, Bool})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Code, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Code, Bool}, Int64, Int64})
precompile(Tuple{typeof(REPL._trimdocs), Markdown.Paragraph, Bool})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Paragraph, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Paragraph, Bool}, Int64, Int64})
precompile(Tuple{typeof(REPL._trimdocs), Markdown.Admonition, Bool})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Admonition, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Admonition, Bool}, Int64, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.MD, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.MD, Bool}, Int64, Int64})
precompile(Tuple{typeof(Base.Unicode.lowercase), String})
precompile(Tuple{typeof(REPL._trimdocs), Markdown.Header{1}, Bool})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Header{1}, Bool}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Markdown.Header{1}, Bool}, Int64, Int64})
precompile(Tuple{typeof(REPL.insert_hlines), Markdown.MD})
precompile(Tuple{typeof(Base.isempty), Array{Base.Docs.DocStr, 1}})
precompile(Tuple{typeof(Base.:(==)), Base.HasLength, Base.HasShape{0}})
precompile(Tuple{typeof(Base.:(==)), Base.HasLength, Base.IsInfinite})
precompile(Tuple{typeof(REPL.insert_internal_warning), Markdown.MD, Base.Set{Pair{Module, Symbol}}})
precompile(Tuple{typeof(Base.show), Base.IOContext{Base.TTY}, Base.Multimedia.MIME{Symbol("text/plain")}, Markdown.MD})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.TTY}, Markdown.MD, Int64})
precompile(Tuple{typeof(Base.:(^)), Char, Int64})
precompile(Tuple{Type{Char}, Char})
precompile(Tuple{typeof(Base.:(|)), UInt32, UInt8})
precompile(Tuple{typeof(Base.leading_zeros), UInt32})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.TTY}, Markdown.Code, Int64})
precompile(Tuple{Markdown.var"#173#174"{Markdown.Code}, Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.TTY}, Markdown.Paragraph, Int64})
precompile(Tuple{Markdown.var"#167#168"{Markdown.Paragraph}, Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{typeof(Markdown.terminline), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Array{Any, 1}})
precompile(Tuple{Type{Pair{A, B} where B where A}, Base.Regex, Char})
precompile(Tuple{typeof(Markdown.terminline), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String})
precompile(Tuple{typeof(Markdown.terminline), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Markdown.Code})
precompile(Tuple{typeof(Markdown.terminline), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Markdown.Link})
precompile(Tuple{typeof(Markdown.terminline_string), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Array{Any, 1}})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.TTY}, Markdown.Admonition, Int64})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:color, :bold), Tuple{Symbol, Bool}}, typeof(Base.printstyled), Base.IOContext{Base.TTY}, String, Vararg{String}})
precompile(Tuple{Base.var"##printstyled#1051", Bool, Bool, Bool, Bool, Bool, Bool, Symbol, typeof(Base.printstyled), Base.IOContext{Base.TTY}, String, Vararg{Any}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:bold, :italic, :underline, :blink, :reverse, :hidden), NTuple{6, Bool}}, typeof(Base.with_output_color), Function, Symbol, Base.IOContext{Base.TTY}, String, Vararg{Any}})
precompile(Tuple{Base.var"##with_output_color#1050", Bool, Bool, Bool, Bool, Bool, Bool, typeof(Base.with_output_color), Function, Symbol, Base.IOContext{Base.TTY}, String, Vararg{Any}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:color, :bold), Tuple{Symbol, Bool}}, typeof(Base.printstyled), Base.IOContext{Base.TTY}, Char, Vararg{Any}})
precompile(Tuple{Base.var"##printstyled#1051", Bool, Bool, Bool, Bool, Bool, Bool, Symbol, typeof(Base.printstyled), Base.IOContext{Base.TTY}, Char, Vararg{Any}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:bold, :italic, :underline, :blink, :reverse, :hidden), NTuple{6, Bool}}, typeof(Base.with_output_color), Function, Symbol, Base.IOContext{Base.TTY}, Char, Vararg{Any}})
precompile(Tuple{Base.var"##with_output_color#1050", Bool, Bool, Bool, Bool, Bool, Bool, typeof(Base.with_output_color), Function, Symbol, Base.IOContext{Base.TTY}, Char, Vararg{Any}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:context,), Tuple{Base.IOContext{Base.TTY}}}, typeof(Base.sprint), Function, Array{Any, 1}, Vararg{Any}})
precompile(Tuple{Base.var"##sprint#539", Base.IOContext{Base.TTY}, Int64, typeof(Base.sprint), Function, Array{Any, 1}, Vararg{Any}})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Array{Any, 1}, Int64})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Markdown.Paragraph, Int64})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:color, :bold), Tuple{Symbol, Bool}}, typeof(Base.printstyled), Base.IOContext{Base.TTY}, String, Vararg{Any}})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.TTY}, Markdown.HorizontalRule, Int64})
precompile(Tuple{typeof(Markdown.term), Base.IOContext{Base.TTY}, Markdown.Header{1}, Int64})
precompile(Tuple{typeof(Markdown.terminline_string), Base.IOContext{Base.TTY}, Array{Any, 1}})
precompile(Tuple{Markdown.var"#171#172"{Char, Int64, String}, Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#114#170", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#114#170", REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{Base.var"#332#333"{REPL.LineEdit.var"#3#4"}, Base.BottomRF{typeof(Base.add_sum)}}, Symbol})
precompile(Tuple{Type{Base.Fix1{F, T} where T where F}, typeof(Base.occursin), Char})
precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{typeof(Base.length), Base.BottomRF{typeof(Base.max)}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{Base.var"#332#333"{REPL.LineEdit.var"#1#2"}, Base.BottomRF{typeof(Base.add_sum)}}, Symbol})
precompile(Tuple{typeof(REPL.LineEdit.complete_line), REPL.LineEdit.PromptState, Int64, Module})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#153#209", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#153#209", REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(REPL.REPLCompletions.completion_text), REPL.REPLCompletions.BslashCompletion})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.var"#102#114"{Base.Regex, Base.Regex, Int64, Int64, REPL.LineEdit.Prompt, REPL.LineEdit.Prompt, REPL.LineEdit.Prompt}, String}, Any, Any})
precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#563#564"}, Symbol})
precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Base.UnitRange{Int64}})
precompile(Tuple{typeof(Base._xfadjoint), Base.BottomRF{Base.var"#563#564"}, Base.Generator{Base.UnitRange{Int64}, typeof(Base.identity)}})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.BottomRF{Base.var"#563#564"}, Base.UnitRange{Int64}}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.BottomRF{Base.var"#563#564"}, Base.UnitRange{Int64}}, Int64, Int64})
precompile(Tuple{REPL.var"#102#114"{Base.Regex, Base.Regex, Int64, Int64, REPL.LineEdit.Prompt, REPL.LineEdit.Prompt, REPL.LineEdit.Prompt}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(Base.readuntil), REPL.Terminals.TTYTerminal, String})
precompile(Tuple{typeof(Base.copyuntil), Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.Terminals.TTYTerminal, String})
precompile(Tuple{typeof(Base.copyuntil), Base.GenericIOBuffer{Array{UInt8, 1}}, Base.TTY, String})
precompile(Tuple{typeof(REPL.LineEdit.push_undo), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(REPL.LineEdit.edit_insert), Base.GenericIOBuffer{Array{UInt8, 1}}, Union{Char, Base.SubString{String}, String}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#264#268"{REPL.LineEdit.PrefixHistoryPrompt}, String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#264#268"{REPL.LineEdit.PrefixHistoryPrompt}, REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{REPL.LineEdit.var"#48#49"{REPL.LineEdit.MIState, REPL.LineEdit.PrefixHistoryPrompt, REPL.LineEdit.Prompt, Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PrefixSearchState, Symbol, REPL.LineEdit.Prompt})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PrefixSearchState, Symbol, String})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PrefixSearchState, Symbol, Int64})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PrefixSearchState, Symbol, REPL.LineEdit.MIState})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PrefixSearchState, Symbol, REPL.LineEdit.InputAreaState})
precompile(Tuple{typeof(REPL.LineEdit.terminal), REPL.LineEdit.PrefixSearchState})
precompile(Tuple{typeof(REPL.LineEdit.write_prompt), Any, REPL.LineEdit.PrefixSearchState, Bool})
precompile(Tuple{typeof(REPL.LineEdit.history_prev_prefix), REPL.LineEdit.PrefixSearchState, REPL.REPLHistoryProvider, AbstractString})
precompile(Tuple{typeof(REPL.LineEdit.transition), Function, REPL.LineEdit.PrefixSearchState, REPL.LineEdit.Prompt})
precompile(Tuple{REPL.var"#76#78"{REPL.LineEdit.PrefixSearchState, REPL.REPLHistoryProvider, Int64}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#249#257", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#249#257", REPL.LineEdit.MIState, REPL.LineEdit.ModeState, Any})
precompile(Tuple{typeof(REPL.LineEdit.history_next_prefix), REPL.LineEdit.PrefixSearchState, REPL.REPLHistoryProvider, AbstractString})
precompile(Tuple{REPL.var"#75#77"{REPL.LineEdit.PrefixSearchState, Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#250#258", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#250#258", REPL.LineEdit.MIState, REPL.LineEdit.ModeState, Union{Char, Base.SubString{String}, String}})
precompile(Tuple{typeof(REPL.LineEdit.accept_result), REPL.LineEdit.MIState, REPL.LineEdit.TextInterface})
precompile(Tuple{typeof(REPL.LineEdit.accept_result_newmode), REPL.REPLHistoryProvider})
precompile(Tuple{typeof(Base.something), Nothing, REPL.LineEdit.Prompt})
precompile(Tuple{REPL.LineEdit.var"#44#45"{REPL.LineEdit.MIState, REPL.LineEdit.PrefixHistoryPrompt, REPL.LineEdit.Prompt}})
precompile(Tuple{typeof(REPL.LineEdit.replace_line), REPL.LineEdit.PromptState, Base.GenericIOBuffer{Array{UInt8, 1}}})
precompile(Tuple{typeof(REPL.LineEdit.match_input), Base.Dict{Char, V} where V, Union{Nothing, REPL.LineEdit.MIState}, Union{Base.GenericIOBuffer{Array{UInt8, 1}}, REPL.Terminals.AbstractTerminal}})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#117#173", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#117#173", REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{typeof(REPL.LineEdit.is_region_active), REPL.LineEdit.PromptState})
precompile(Tuple{typeof(Base.min), Float64, Float64})
precompile(Tuple{typeof(Base.setproperty!), REPL.LineEdit.PromptState, Symbol, Float64})
precompile(Tuple{typeof(Base.copymutable), Array{String, 1}})
precompile(Tuple{Type{NamedTuple{(:beeping,), T} where T<:Tuple}, Tuple{Bool}})
precompile(Tuple{typeof(Base.pairs), NamedTuple{(:beeping,), Tuple{Bool}}})
precompile(Tuple{REPL.LineEdit.var"#6#7"{Bool, REPL.LineEdit.PromptState, Float64, Array{String, 1}}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.UnixTerminal, Any})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, typeof(REPL.LineEdit.refresh_multi_line), REPL.Terminals.TerminalBuffer, REPL.Terminals.UnixTerminal, Union{REPL.LineEdit.PrefixSearchState, REPL.LineEdit.PromptState}})
precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:beeping,), Tuple{Bool}}, Type{NamedTuple{(:beeping,), T} where T<:Tuple}})
precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:exception, :backtrace), Tuple{MethodError, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}}, Symbol})
precompile(Tuple{typeof(Base.scrub_repl_backtrace), Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}})
precompile(Tuple{typeof(Base.StackTraces.get_inlinetable), Nothing})
precompile(Tuple{typeof(Base.StackTraces.get_method_instance_roots), Nothing})
precompile(Tuple{Type{Base.StackTraces.StackFrame}, Symbol, Symbol, Int64, Nothing, Bool, Bool, UInt64})
precompile(Tuple{typeof(Base.getindex), Array{Any, 1}, Int32})
precompile(Tuple{typeof(Base.StackTraces.get_method_instance_roots), Core.MethodInstance})
precompile(Tuple{typeof(Base.filter), Base.StackTraces.var"#3#4", Array{Any, 1}})
precompile(Tuple{Type{Base.StackTraces.StackFrame}, Symbol, Symbol, Int64, Core.MethodInstance, Bool, Bool, UInt64})
precompile(Tuple{Base.StackTraces.var"#5#6"{Symbol, Symbol, Symbol}, Core.MethodInstance})
precompile(Tuple{typeof(Base.filter!), Base.StackTraces.var"#1#2", Array{Core.LineInfoNode, 1}})
precompile(Tuple{Type{Base.StackTraces.StackFrame}, Symbol, Symbol, Int64, Module, Bool, Bool, UInt64})
precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:exception, :backtrace), Tuple{MethodError, Array{Base.StackTraces.StackFrame, 1}}}, Symbol})
precompile(Tuple{typeof(Base.length), Array{Base.StackTraces.StackFrame, 1}})
precompile(Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.IOContext{Base.TTY}, Pair{Symbol, Base.RefValue{Bool}}})
precompile(Tuple{typeof(Base.display_error), Base.IOContext{Base.TTY}, Base.ExceptionStack})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:bold, :color), Tuple{Bool, Symbol}}, typeof(Base.printstyled), Base.IOContext{Base.TTY}, String})
precompile(Tuple{typeof(Base.indexed_iterate), NamedTuple{(:exception, :backtrace), Tuple{MethodError, Array{Base.StackTraces.StackFrame, 1}}}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), NamedTuple{(:exception, :backtrace), Tuple{MethodError, Array{Base.StackTraces.StackFrame, 1}}}, Int64, Int64})
precompile(Tuple{Type{NamedTuple{(:digit_align_width,), T} where T<:Tuple}, Tuple{Int64}})
precompile(Tuple{typeof(Base.reverse), Tuple{String, String}})
precompile(Tuple{typeof(Base.revargs), String, String})
precompile(Tuple{typeof(Base.getproperty), Base.Order.By{Base.var"#981#988", Base.Order.ForwardOrdering}, Symbol})
precompile(Tuple{typeof(Base.getproperty), Base.Order.Lt{Base.Sort.var"#26#27"{Base.Order.By{Base.var"#981#988", Base.Order.ForwardOrdering}}}, Symbol})
precompile(Tuple{typeof(Base._nt_names), Type{NamedTuple{(:scratch,), Tuple{Array{Any, 1}}}}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:backtrace,), Tuple{Bool}}, typeof(Base.showerror), Base.IOContext{Base.TTY}, MethodError, Array{Base.StackTraces.StackFrame, 1}})
precompile(Tuple{typeof(Base.typesof), Any, Vararg{Any}})
precompile(Tuple{typeof(Base.print), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, String, Type})
precompile(Tuple{typeof(Base.Unicode.textwidth), Char})
precompile(Tuple{typeof(Base.iterate), Base.ANSIIterator, Tuple{Int64, Tuple{Base.RegexMatch{String}, Tuple{Int64, Bool}}}})
precompile(Tuple{typeof(Base.iterate), Base.RegexMatchIterator{String}, Tuple{Int64, Bool}})
precompile(Tuple{typeof(Base.iterate), Base.ANSIIterator, Tuple{Int64, Nothing}})
precompile(Tuple{typeof(Base.getindex), Array{Int16, 1}, Int64})
precompile(Tuple{typeof(Base.:(<)), Int16, Int64})
precompile(Tuple{typeof(Base.:(>)), Int16, Int64})
precompile(Tuple{typeof(Base.:(>)), Int16, Int16})
precompile(Tuple{typeof(Base.noncallable_number_hint_handler), Vararg{Any, 4}})
precompile(Tuple{typeof(Base.getproperty), MethodError, Symbol})
precompile(Tuple{typeof(Base.string_concatenation_hint_handler), Vararg{Any, 4}})
precompile(Tuple{Base.var"#980#987"{Array{Any, 1}}, Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}})
precompile(Tuple{Type{String}, Array{UInt8, 1}})
precompile(Tuple{typeof(Base.empty!), Array{Tuple{String, Int64}, 1}})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.StackTraces.StackFrame, Int64}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.StackTraces.StackFrame, Int64}, Int64, Int64})
precompile(Tuple{typeof(Base.push!), Array{Tuple{String, Int64}, 1}, Tuple{String, Int64}})
precompile(Tuple{typeof(Core.Compiler.builtin_tfunction), REPL.REPLCompletions.REPLInterpreter, Any, Array{Any, 1}, Core.Compiler.InferenceState})
precompile(Tuple{typeof(Core.Compiler.cache_result!), REPL.REPLCompletions.REPLInterpreter, Core.Compiler.InferenceResult})
precompile(Tuple{typeof(Core.Compiler.from_interprocedural!), REPL.REPLCompletions.REPLInterpreter, Any, Core.Compiler.InferenceState, Core.Compiler.ArgInfo, Any})
precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:exception, :backtrace), Tuple{BoundsError, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}}, Symbol})
precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:exception, :backtrace), Tuple{BoundsError, Array{Base.StackTraces.StackFrame, 1}}}, Symbol})
precompile(Tuple{typeof(Base.indexed_iterate), NamedTuple{(:exception, :backtrace), Tuple{BoundsError, Array{Base.StackTraces.StackFrame, 1}}}, Int64})
precompile(Tuple{typeof(Base.indexed_iterate), NamedTuple{(:exception, :backtrace), Tuple{BoundsError, Array{Base.StackTraces.StackFrame, 1}}}, Int64, Int64})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:backtrace,), Tuple{Bool}}, typeof(Base.showerror), Base.IOContext{Base.TTY}, BoundsError, Array{Base.StackTraces.StackFrame, 1}})
precompile(Tuple{typeof(Base.summary), Base.IOContext{Base.TTY}, Array{Any, 1}})
precompile(Tuple{typeof(Base.Iterators.enumerate), Tuple{Int64}})
precompile(Tuple{typeof(Base.iterate), Base.Iterators.Enumerate{Tuple{Int64}}, Tuple{Int64}})
precompile(Tuple{typeof(Base.show_index), Base.IOContext{Base.TTY}, Int64})
precompile(Tuple{typeof(Base.iterate), Base.Iterators.Enumerate{Tuple{Int64}}, Tuple{Int64, Int64}})
precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:use_color,), Tuple{Bool}}, typeof(Base.print_type_bicolor), Base.IOContext{Base.GenericIOBuffer{Array{UInt8, 1}}}, Type})
precompile(Tuple{typeof(Base.:(==)), Int16, Int64})
precompile(Tuple{REPL.LineEdit.var"#27#28"{REPL.LineEdit.var"#119#175", String}, Any, Any})
precompile(Tuple{REPL.LineEdit.var"#119#175", REPL.LineEdit.MIState, Any, Vararg{Any}})
precompile(Tuple{REPL.LineEdit.var"##edit_abort#113", Any, typeof(REPL.LineEdit.edit_abort), REPL.LineEdit.MIState, Bool})
precompile(Tuple{REPL.var"#62#68"{REPL.REPLBackendRef}})
precompile(Tuple{typeof(Base._atexit), Int32})
precompile(Tuple{REPL.var"#94#106"{REPL.REPLHistoryProvider}, Any})
precompile(Tuple{Type{StyledStrings.Face}, Nothing, Nothing, Nothing, Nothing, Nothing, StyledStrings.SimpleColor, Nothing, Nothing, Nothing, Array{Symbol, 1}})

@LilithHafner
Copy link
Member

That 750 should be 0. #51557

@tecosaur
Copy link
Member Author

Ooof, well at least it's not a problem I'm accidently introducing here.

@tecosaur
Copy link
Member Author

Ok, I'm about to push a much more conservative take, that only has four variants.

  1. The current big banner
  2. Big banner, with text below
  3. The (previously PR'd) small banner
  4. A last-resort one-liner

(1) and (2) should look pretty familiar, it's just the current banner with:

  • Box drawing characters for the vertical divider, and desaturated
  • Turning the docs URL and Pkg into terminal-links
  • Making the ? and ] for the help/pkg repl modes match the colour of those modes
  • A more colourful dev line

10-23-22:10-Julia ● ~-4

10-23-22:10-Julia ● ~-5

(3) and (4) are only used by default in very extreme situations, namely TTYs of 1-3 rows (where even scrolling the big banner feels silly).

10-23-22:10-Julia ● ~-2

10-23-22:10-Julia ● ~-3

@tecosaur
Copy link
Member Author

tecosaur commented Oct 23, 2023

Regarding the precompile behaviour alluded to earlier, I'd appreciate eyes on JuliaLang/StyledStrings.jl#6.

Now resolved.

@PallHaraldsson
Copy link
Contributor

The "Rotated", with the logo on top, banner works with/respects small horizontal space, but I would also like to limit vertical space, why I suggested the new version 5 as the default or (same-sized) with braille dots.

I don't have the use-case of narrow/tiled windows, by I think I at least would want to go straight to the "last-resort one-liner", and be annoyed by getting a double vertical spaced one, why I suggested only 2 is enough. You can merge as is, or with such a change, since it does't affect me much. I think I would personally opt-into the tiny one always. It's better than turning it off, since it can be helpful to know which version you're using, at least for power-users (and most other likely would not opt-into a non-default, or know how). I note python3 has only a 2-line banner...

@tecosaur
Copy link
Member Author

I would also like to limit vertical space

So would I, but it seems that larger changes are more controversial, so I'd like to leave that to a subsequent PR/discussion.

This slimmed-down version doesn't really add any new banners, other than the "rotated" form, but does solve the banner-reflow issue, so I'm inclined to not let perfect be the enemy of better, and settle for that improvement for now.

@ParadaCarleton
Copy link

I really like the braille dots!

@tecosaur
Copy link
Member Author

Yea, the braille dots are really cool. I'd like to explore them further.

@LilithHafner
Copy link
Member

I think the moving banner to REPL part of this is ready to merge. If you split it out into a separate PR we can merge that now and make reviewing this PR easier. Using multiple well-factored commits is helpful, but it would be even better to do two separate PRs so that discussion and CI can be separate.

As for the second commit, having both (3) and (4) seems a bit excessive. Specifically, I don't like that the distinction between a TTY 3-4 lines tall vs a TTY 0-2 lines tall results in a semantic change in which information is displayed.

Also, an objection to (4), the one line fallback, all other banners display the branch name. The only other way to get the branch name is Base.GIT_VERSION_INFO.branch which I believe is internal and is also not something I want to have to remember.

imo

∴ Julia 1.9.3 (2023-08-24)

is good but

∴ Julia 1.11.0-DEV.707 (2023-10-20)

is missing important information. I think we should only omit the commit_string if it is "Official https://julialang.org/ release" (it may be difficult to write tests for behavior that is dependent on weather or not the build is official)

@tecosaur tecosaur force-pushed the banner-to-repl branch 2 times, most recently from 7d1267e to 9d984f2 Compare October 24, 2023 11:58
@tecosaur
Copy link
Member Author

Oh, I've also just switched the internal number-name (now: 0=off, 1=largest, ..., 4=smallest) association to be a bit more sensible, thought I might as well toss that in while fixing up the tests.

I've also just noticed that the "invalid argument" message needs to be updated, which I've just done.

I think this should be good to go at this stage :)

Copy link
Member

@fingolfin fingolfin left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

@tecosaur
Copy link
Member Author

tecosaur commented Oct 3, 2024

If somebody's willing to approve and merge this, I'll muster up the willpower to resolve the latest merge conflict.

@fingolfin
Copy link
Member

I've already approved this, but of course it'd be nice if some more people gave it a thumbs up

@tecosaur
Copy link
Member Author

tecosaur commented Oct 4, 2024

Maybe I should be more willing to merge my own PRs, but somehow the idea of doing so feels wrong to me. I've got a strong ingrained feeling that in a project like this I should almost never merge my own PRs, and it's hard to shake.

@christiangnrd
Copy link
Contributor

Bump and backport 1.12?

@tecosaur
Copy link
Member Author

Probably not backport now that we've had the feature freeze. Anyway, I still feel uncomfortable with merging my own PRs, so this is ultimately waiting for somebody else who's willing to review + merge (at which point I'll find the time to resolve the latest merge conflict).

@PallHaraldsson
Copy link
Contributor

PallHaraldsson commented Feb 28, 2025

@fingolfin approved way before the feature freeze. This is a nice little feature, so I think we should just merge it (but I have no power here; to do that).

alpha1 seems days away, would be good to get it in, because, it's a feature we can live without, and plenty of time to just drop it if problematic. This shouldn't slow down startup much, at least not without a REPL (my issue I just opened), and I can't think of many objections to this, even if measurably slower, but not noticeable.

I would test this if I could...:

$ juliaup add pr51811
Installing Julia pr51811-linux-x86_64
Error: Failed to download and extract pr or nightly: Failed to get etag from `https://julialangnightlies-s3.julialang.org/bin/linux/x86_64/julia-pr51811-linux-x86_64.tar.gz`.
This is likely due to requesting a pull request that does not have a cached build available. You may have to build locally.

@StefanKarpinski
Copy link
Member

StefanKarpinski commented Mar 18, 2025

I like this. Let's do it. Before/after feature freeze doesn't really matter—it will eventually be in a release. This is definitely not worth a backport, please stop suggesting that minor features that you happen to like get backported.

@tecosaur
Copy link
Member Author

tecosaur commented Mar 18, 2025

I've resolved the merge conflicts and confirmed it works, but checking perf it seems like there's now a substantial of non-precompiled code that's run, increasing the REPL latency by a noticeable amount.

--trace-compile=... --trace-compile-timing
#=    6.0 ms =# precompile(Tuple{typeof(Base.mapreduce), Function, Function, Tuple{Base.AnnotatedString{String}, String, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}, String}})
#=   10.8 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, Symbol}, Int64})
#=   18.9 ms =# precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Symbol, Any}, Int64}, Int64, Tuple{Symbol, Symbol}})
#=   12.7 ms =# precompile(Tuple{Core.GeneratedFunctionStub, UInt64, Method, Any, Vararg{Any}}) # recompile
#=    2.8 ms =# precompile(Tuple{typeof(Base._reverse_iter), NTuple{10, Symbol}})
#=    1.9 ms =# precompile(Tuple{Type{NamedTuple{(:init,), T} where T<:Tuple}, Tuple{UInt64}})
#=  139.4 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, StyledStrings.Face}, Int64})
#=   27.7 ms =# precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Symbol, Any}, Int64}, Int64, Tuple{Symbol, StyledStrings.Face}})
#=    5.0 ms =# precompile(Tuple{typeof(Base.isequal), Tuple{Symbol, StyledStrings.Face}, Tuple{Symbol, StyledStrings.Face}})
#=    6.2 ms =# precompile(Tuple{typeof(Base.:(==)), Tuple{Nothing, Nothing, Nothing, Symbol, Nothing, Nothing, Nothing, Nothing, Nothing, Array{Symbol, 1}}, Tuple{Nothing, Nothing, Nothing, Symbol, Nothing, Nothing, Nothing, Nothing, Nothing, Array{Symbol, 1}}})
#=    5.3 ms =# precompile(Tuple{typeof(Base.delete!), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, StyledStrings.Face}})
#=    3.9 ms =# precompile(Tuple{typeof(Base.mapreduce), Function, Function, Tuple{Base.AnnotatedString{String}, Base.AnnotatedString{String}, Base.AnnotatedString{String}}})
#=    2.0 ms =# precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(>=)), Tuple{Int64, Int64}, Tuple{Int64, Int64}})
#=    1.6 ms =# precompile(Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}})
#=    2.1 ms =# precompile(Tuple{typeof(Base.copy), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}})
#=    3.9 ms =# precompile(Tuple{typeof(Base.mapreduce), Function, Function, NTuple{10, Base.AnnotatedString{String}}})
#=    3.9 ms =# precompile(Tuple{typeof(Base.delete!), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, Symbol}})
#=   10.6 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, String}, Int64})
#=   18.1 ms =# precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Symbol, Any}, Int64}, Int64, Tuple{Symbol, String}})
#=    6.1 ms =# precompile(Tuple{typeof(Base.:(==)), Tuple{Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, StyledStrings.SimpleColor, Nothing, Nothing, Array{Symbol, 1}}, Tuple{Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, StyledStrings.SimpleColor, Nothing, Nothing, Array{Symbol, 1}}})
#=    3.3 ms =# precompile(Tuple{typeof(Base.hashindex), Tuple{Symbol, Symbol}, Int64})
#=    3.6 ms =# precompile(Tuple{typeof(Base.hashindex), Tuple{Symbol, String}, Int64})
#=    4.5 ms =# precompile(Tuple{typeof(Base.hashindex), Tuple{Symbol, StyledStrings.Face}, Int64})
#=    1.6 ms =# precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Any}})
#=   20.6 ms =# precompile(Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), typeof(Base.merge), Base._InitialValue, Array{StyledStrings.Face, 1}})
#=    7.5 ms =# precompile(Tuple{Base.var"#readcb_specialized#uv_readcb##0", Base.TTY, Int64, UInt64})
#=   12.1 ms =# precompile(Tuple{typeof(Base.peek), Base.TTY, Type{UInt8}})
#=    5.5 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Char, Any}, Char, Nothing})
#=    1.5 ms =# precompile(Tuple{Base.Returns{Symbol}, Any})
#=    2.6 ms =# precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.GenericIOBuffer{Memory{UInt8}}, Bool, Bool}, Int64})
#=    2.6 ms =# precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.GenericIOBuffer{Memory{UInt8}}, Bool, Bool}, Int64, Int64})
#=   17.0 ms =# precompile(Tuple{typeof(Base._atexit), Int32}) # recompile

I suspect that this is best handled as a push to actually precompile more in StyledStrings, and remove the 4 instances of broadcasting.

@DilumAluthge
Copy link
Member

I see the forget me not label here. @tecosaur What's the latest status on this PR?

@tecosaur
Copy link
Member Author

I haven't given this a lot of attention since (I generally don't tend to have much success trying to reduce precompilation, even with a large amount of time/effort), but I have made some changes that should help (e.g. removing broadcasting, as mentioned).

To be clear, in my eyes, the only blocker is the latency hit from methods that aren't precompiled/are re-compiled.

I'm also going to cross my fingers and hope that there might be compiler/precompilation changes that may help with:

  • Base methods that are part of this, e.g. precompile(Tuple{typeof(Base.peek), Base.TTY, Type{UInt8}})
  • Recompilation that is part of this, e.g. precompile(Tuple{typeof(Base._atexit), Int32})

With StyledStrings being used more in the REPL too in PRs like #59778 and #59819 that will/seem likely to be part of 1.13, I think it would be nice to get this work in too, to form a larger batch of REPL-related improvements in 1.13.

@tecosaur
Copy link
Member Author

After some help from @vchuravy investigating why precompilation isn't working as well as it used to, the jump in latency that's now holding up merging has been speculatively connected to c31710a.

At the very least, wrapping the REPL precompilation workload in ccall(:jl_tag_newly_inferred_enable, Cvoid, ()) / ccall(:jl_tag_newly_inferred_disable, Cvoid, ()) cuts the added latency down to +93ms from +390ms.

After #59850, here's what remains:

#=    4.9 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, Symbol}, Int64})
#=   20.3 ms =# precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Symbol, Any}, Int64}, Int64, Tuple{Symbol, Symbol}})
#=    3.0 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, StyledStrings.Face}, Int64})
#=   28.8 ms =# precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Symbol, Any}, Int64}, Int64, Tuple{Symbol, StyledStrings.Face}})
#=    2.0 ms =# precompile(Tuple{typeof(Base.all), Tuple{Bool, Bool}})
#=   10.7 ms =# precompile(Tuple{typeof(Base.get), Base.Dict{Tuple{Symbol, Any}, Int64}, Tuple{Symbol, String}, Int64})
#=   18.8 ms =# precompile(Tuple{typeof(Base.setindex!), Base.Dict{Tuple{Symbol, Any}, Int64}, Int64, Tuple{Symbol, String}})
#=    2.9 ms =# precompile(Tuple{typeof(Base.hashindex), Tuple{Symbol, String}, Int64})
#=    1.6 ms =# precompile(Tuple{typeof(Base.isempty), Base.Dict{String, Any}})

At the very least, I think this now gives us enough information to indicate that the precompilation problems lie outside this PR.

Given this, I'm inclined to suggest that this should be merged for 1.13.

vchuravy added a commit that referenced this pull request Oct 16, 2025
REPL precompile scripts runs a workload and might thus encounter code in
other standard libraries that needs to be precompiled. Before #54899 we
had a bespoke variant of PrecompileTools.jl. PrecompileTools was fixed
with #57828 so we can now re-instate the support in REPL.

Noticed by @tecosaur, while looking at #51811
@tecosaur
Copy link
Member Author

Now #59850 has been merged, the latency hit is ~90ms. Not great, but not nearly as bad as ~400ms.

Given this, is it best to:

  1. Merge this and then get the remaining precompile statements down, or
  2. Leave this be until the remaining precompilation-related issues are worked out, or
  3. Toss the precompile lines above at the end of the REPL precompile file (reduces the latency hit to ~10ms), and merge

Thoughts?

KristofferC pushed a commit that referenced this pull request Oct 16, 2025
REPL precompile scripts runs a workload and might thus encounter code in
other standard libraries that needs to be precompiled. Before #54899 we
had a bespoke variant of PrecompileTools.jl. PrecompileTools was fixed
with #57828 so we can now re-instate the support in REPL.

Noticed by @tecosaur, while looking at #51811

(cherry picked from commit ecfec85)
@tecosaur
Copy link
Member Author

I'll also note that there is exactly one test failure that's responsible for the Test ❌, and it's with threading (i.e. unrelated).

@tecosaur
Copy link
Member Author

tecosaur commented Oct 19, 2025

I figure it's probably best to go with the approach of including the precompile statements currently needed to make the latency difference negligible, and then hope that in the future precompilation work allows them to be deleted.

According to hyperfine, REPL latency is actually faster slightly than current after this PR (I'm guessing due to the manual precompilation):

~$ hyperfine 'julia +nightly --startup-file=no -e "using REPL; REPL.banner(stdout)"' 'julia +dev --startup-file=no -e "using REPL; REPL.banner(stdout)"'
Benchmark 1: julia +nightly --startup-file=no -e "using REPL; REPL.banner(stdout)"
  Time (mean ± σ):     188.7 ms ±   8.6 ms    [User: 132.4 ms, System: 75.6 ms]
  Range (min … max):   181.8 ms … 211.7 ms    14 runs
 
Benchmark 2: julia +dev --startup-file=no -e "using REPL; REPL.banner(stdout)"
  Time (mean ± σ):     172.9 ms ±   3.0 ms    [User: 125.7 ms, System: 65.9 ms]
  Range (min … max):   169.4 ms … 178.7 ms    17 runs
 
Summary
  julia +dev --startup-file=no -e "using REPL; REPL.banner(stdout)" ran
    1.09 ± 0.05 times faster than julia +nightly --startup-file=no -e "using REPL; REPL.banner(stdout)"

This may be affected by whether stdout is :color => true or not, so I also ran hyperfine with --show-output

--show-output
    Print the stdout and stderr of the benchmark instead of suppressing
    it. This will increase the time it takes for benchmarks to run, so it
    should only be used for debugging purposes or when trying to benchmark
    output speed.

Results:

~$ hyperfine --show-output 'julia +nightly --startup-file=no -e "using REPL; REPL.banner(stdout)"' 'julia +dev --startup-file=no -e "using REPL; REPL.banner(stdout)"'
Benchmark 1: julia +nightly --startup-file=no -e "using REPL; REPL.banner(stdout)"
  Time (mean ± σ):     194.0 ms ±   5.7 ms    [User: 136.7 ms, System: 78.6 ms]
  Range (min … max):   185.3 ms … 208.8 ms    15 runs

Benchmark 2: julia +dev --startup-file=no -e "using REPL; REPL.banner(stdout)"
  Time (mean ± σ):     170.0 ms ±   5.4 ms    [User: 128.6 ms, System: 63.9 ms]
  Range (min … max):   164.6 ms … 182.3 ms    16 runs
 
Summary
  julia +dev --startup-file=no -e "using REPL; REPL.banner(stdout)" ran
    1.14 ± 0.05 times faster than julia +nightly --startup-file=no -e "using REPL; REPL.banner(stdout)"

We also spritz it up a bit using the new StyledStrings library, namely:
- colouring the Help and Pkg key prompts
- making the docs link a terminal link, and Pkg a link to the Pkg docs
- using box drawing characters for the dividing line
- making branch status more colourful
- making the official version text more subdued

With these change the four banners (from smallest to largest) are:
1. A one-liner, for extreme circumstances (new)
2. The short banner
3. The large banner, with the description stacked vertically (new)
4. The large banner, with the description stacked horizontally

Because precompilation is a little flakey at the moment, I add a bunch
of precompile statements to prevent latency from regressing.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

display and printing Aesthetics and correctness of printed representations of objects. REPL Julia's REPL (Read Eval Print Loop)

Projects

None yet

Development

Successfully merging this pull request may close these issues.