Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Make banner size depend on terminal size #51811

Open
wants to merge 1 commit into
base: master
Choose a base branch
from

Conversation

tecosaur
Copy link
Contributor

@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 stdlib:REPL Julia's REPL (Read Eval Print Loop) domain:display and printing Aesthetics and correctness of printed representations of objects. labels Oct 21, 2023
@IanButterworth
Copy link
Sponsor 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
Contributor 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
Contributor 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
Contributor 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
Sponsor 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
Contributor 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
Contributor 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
Contributor Author

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

@tecosaur
Copy link
Contributor 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
Contributor 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
Contributor 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
Contributor

I really like the braille dots!

@tecosaur
Copy link
Contributor 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 tecosaur force-pushed the banner-to-repl branch 2 times, most recently from 1cc215b to 75c6468 Compare February 12, 2024 08:55
@tecosaur
Copy link
Contributor Author

To add some context that was laid out on Slack, Kristoffer is referring to the 6 banners in the original post, which I agree aren't a good idea. The PR has become much more conservative since then.

With the (minor) tweaks to the styling that have occurred since the last screenshots, I think it's worth giving screenshots of the current incarnation again.

The current banner, spruced up slightly

02-12-16:02-Julia ● ~

New banner for narrower terminals

02-12-16:02-Julia ● ~-1

The current short banner, spruced up slightly

02-12-16:02-Julia ● ~-2

1-liner for extreme cases

I can't actually get the 1-liner to show automatically in my standard terminal, since it seems to have had an update that introduced a minimum height, but it's still there for extreme cases or if explicitly requested.

02-12-16:02-Julia ● ~-4

@tecosaur
Copy link
Contributor Author

tecosaur commented Feb 12, 2024

If it's needed to get into 1.11 (just to avoid the conflict with --banner=short headache) I'd be willing to drop the "vertically stacked" and "1-liner" banner variants and put them in another PR, though I think it's nice getting them too here.

@tecosaur tecosaur added the backport 1.11 Change should be backported to release-1.11 label Feb 16, 2024
@paemurru
Copy link

If I have three differently-sized terminals open, I think I would rather not want to see three slightly different banners. In OSCAR we just have the usual banner and a one-line banner.

How was the braille dots banner produced? That one looks very nice.

@tecosaur
Copy link
Contributor Author

tecosaur commented Mar 2, 2024

If I have three differently-sized terminals open, I think I would rather not want to see three slightly different banners.

I suspect that people here are over-estimating how much they'll see different banners in practice. If you're curious/suspicious, I'd encourage you to check out this branch 🙂.

For context, here's a haphazard tiling of terminals I put together using the current state of this PR:

image

@KristofferC KristofferC mentioned this pull request Mar 6, 2024
60 tasks
KristofferC added a commit that referenced this pull request Mar 17, 2024
Backported PRs:
- [x] #39071 <!-- Add a lazy `logrange` function and `LogRange` type -->
- [x] #51802 <!-- Allow AnnotatedStrings in log messages -->
- [x] #53369 <!-- Orthogonalize re-indexing for FastSubArrays -->
- [x] #48050 <!-- improve `--heap-size-hint` arg handling -->
- [x] #53482 <!-- add IR encoding for EnterNode -->
- [x] #53499 <!-- Avoid compiler warning about redefining jl_globalref_t
-->
- [x] #53507 <!-- update staled `Core.Compiler.Effects` documentation
-->
- [x] #53408 <!-- task splitting: change additive accumulation to
multiplicative -->
- [x] #53523 <!-- add back an alias for `check_top_bit` -->
- [x] #53377 <!-- add _readdirx for returning more object info gathered
during dir scan -->
- [x] #53525 <!-- fix InteractiveUtils call in Base.runtests on failure
-->
- [x] #53540 <!-- use more efficient `_readdirx` for tab completion -->
- [x] #53545 <!-- use `_readdirx` for `walkdir` -->
- [x] #53551 <!-- revert "Add @create_log_macro for making custom styled
logging macros (#52196)" -->
- [x] #53554 <!-- Always return a value in 1-d circshift! of
abstractarray.jl -->
- [x] #53424 <!-- yet more atomics & cache-line fixes on work-stealing
queue -->
- [x] #53571 <!-- Update Documenter to v1.3 for inventory writing -->
- [x] #53403 <!-- Move parallel precompilation to Base -->
- [x] #53589 <!-- add back `unsafe_convert` to pointer for arrays -->
- [x] #53596 <!-- build: remove extra .a file -->
- [x] #53606 <!-- fix error path in `precompilepkgs` -->
- [x] #53004 <!-- Unexport with, at_with, and ScopedValue from Base -->
- [x] #53629 <!-- typo fix in scoped values docs -->
- [x] #53630 <!-- sroa: Fix incorrect scope counting -->
- [x] #53598 <!-- Use Base parallel precompilation to build stdlibs -->
- [x] #53649 <!-- precompilepkgs: package in boths deps and weakdeps are
in fact only weak -->
- [x] #53671 <!-- Fix bootstrap Base precompile in cross compile
configuration -->
- [x] #52125 <!-- Load Pkg if not already to reinstate missing package
add prompt -->
- [x] #53602 <!-- Handle zero on arrays of unions of number types and
missings -->
- [x] #53516 <!-- permit NamedTuple{<:Any, Union{}} to be created -->
- [x] #53643 <!-- Bump CSL to 1.1.1 to fix libgomp bug -->
- [x] #53679 <!-- move precompile workload back from Base -->
- [x] #53663 <!-- add isassigned methods for reinterpretarray -->
- [x] #53662 <!-- [REPL] fix incorrectly cleared line after completions
accepted -->
- [x] #53611 <!-- Linalg: matprod_dest for Diagonal and adjvec -->
- [x] #53659 <!-- fix #52025, re-allow all implicit pointer casts in
cconvert for Array -->
- [x] #53631 <!-- LAPACK: validate input parameters to throw informative
errors -->
- [x] #53628 <!-- Make some improvements to the Scoped Values
documentation. -->
- [x] #53655 <!-- Change tbaa of ptr_phi to tbaa_value  -->
- [x] #53391 <!-- Default to the medium code model in x86 linux -->
- [x] #53699 <!-- Move `isexecutable, isreadable, iswritable` to
`filesystem.jl` -->
- [x] #41232 <!-- Fix linear indexing for ReshapedArray if the parent
has offset axes -->
- [x] #53527 <!-- Enable analyzegc checks for try catch and fix found
issues -->
- [x] #52092 
- [x] #53682 <!-- Increase build precompilation -->
- [x] #53720 
- [x] #53553 <!-- typeintersect: fix `UnionAll` unaliasing bug caused by
innervars. -->

Contains multiple commits, manual intervention needed:
- [ ] #53305 <!-- Propagate inbounds in isassigned with CartesianIndex
indices -->

Non-merged PRs with backport label:
- [ ] #53736 <!-- fix literal-pow to return the right type when the base
is -1 -->
- [ ] #53707 <!-- Make ScopedValue public -->
- [ ] #53696 <!-- add invokelatest to on_done callback in bracketed
paste -->
- [ ] #53660 <!-- put Logging back in default sysimage -->
- [ ] #53509 <!-- revert moving "creating packages" from Pkg.jl -->
- [ ] #53452 <!-- RFC: allow Tuple{Union{}}, returning Union{} -->
- [ ] #53402 <!-- Add `jl_getaffinity` and `jl_setaffinity` -->
- [ ] #52694 <!-- Reinstate similar for AbstractQ for backward
compatibility -->
- [ ] #51928 <!-- Styled markdown, with a few tweaks -->
- [ ] #51816 <!-- User-themable stacktraces -->
- [ ] #51811 <!-- Make banner size depend on terminal size -->
- [ ] #51479 <!-- prevent code loading from lookin in the versioned
environment when building Julia -->
@KristofferC KristofferC mentioned this pull request Mar 20, 2024
41 tasks
@KristofferC KristofferC mentioned this pull request Apr 17, 2024
59 tasks
@LilithHafner LilithHafner removed the backport 1.11 Change should be backported to release-1.11 label May 9, 2024
@tecosaur
Copy link
Contributor Author

tecosaur commented May 9, 2024

Triage: Because this has sat around for so long, let's leave it to 1.12. If we use names for the maximum sizes (e.g. "tiny", "small", "narrow"), then it's not breaking any more.

Triage also generally likes the look of this as of the 4-variant version.

@tecosaur tecosaur added the status:forget me not PRs that one wants to make sure aren't forgotten label May 9, 2024
@StefanKarpinski
Copy link
Sponsor Member

Yeah, we can have options to suppress this as well, but I think this will be a much nicer default experience. I expect the tiny banner to be extremely rare, and when it gets used any banner would look terrible anyway. The normal and narrow banners look essentially the same stylistically, the narrow one is just a cleverly "wrapped" version of the normal one. The short one does look different but I suspect will also be pretty rare.

@tecosaur
Copy link
Contributor Author

I think the update I've just pushed does the rename suggested by Triage, I've just been unable to test since with the current master/HEAD (pre)compilation during make never finishes on my machine:

Collecting and executing precompile statements
└ Collect (Basic: ◑ ) => Execute ◑ 83Unhandled Task ERROR: failed process: Process(setenv(`/home/tec/Documents/Projects/julia/usr/bin/julia -O0 --trace-compile=/tmp/jl_uwmRkK/jl_54FYt6Vwho --sysimage /home/tec/Documents/Projects/julia/usr/lib/julia/sys.ji --cpu-target=native --startup-file=no --color=yes --project=/tmp/jl_uwmRkK/__PackagePrecompilationStatementModule`

@tecosaur tecosaur force-pushed the banner-to-repl branch 3 times, most recently from 1441d5c to 010f62f Compare July 20, 2024 14:32
@StefanKarpinski
Copy link
Sponsor Member

Is this working again for you?

@tecosaur
Copy link
Contributor Author

Yep, the issue I mentioned was solved just be rebasing on a newer master, and then the last few force pushes has just been making the required tweaks to the tests.

@tecosaur
Copy link
Contributor 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 :)

src/jloptions.c Outdated Show resolved Hide resolved
Copy link
Contributor

@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

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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
domain:display and printing Aesthetics and correctness of printed representations of objects. status:forget me not PRs that one wants to make sure aren't forgotten stdlib:REPL Julia's REPL (Read Eval Print Loop)
Projects
None yet
Development

Successfully merging this pull request may close these issues.