Skip to content

Instantly share code, notes, and snippets.

@NHDaly

NHDaly/changes-to-julia-stdlib-inlining-v1.0.3-cleaned.txt

Last active January 18, 2019 18:23
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save NHDaly/30eb8c043640c1ba43776fdd5b317924 to your computer and use it in GitHub Desktop.
Save NHDaly/30eb8c043640c1ba43776fdd5b317924 to your computer and use it in GitHub Desktop.
Download ZIP
All the newly inlined methods from v1.0.1 to v1.0.3, printed from here (https://github.com/JuliaLang/julia/compare/v1.0.3...NHDaly:4cf5ec8d90) and cleaned from here (https://gist.github.com/NHDaly/d0d74eba91468bf6efe101a6673bbc9f)
Raw
changes-to-julia-stdlib-inlining-v1.0.3-cleaned.txt
promote_type(Type{T}, Type{UInt64}) where {T}
promote_type(Type{Bool}, Type{S}) where {S}
promote_type(Type{Bool}, Type{#s55} where #s55<:Integer)
promote_type(Type{T}, Type{UInt32}) where {T}
promote_type(Type{UInt64}, Type{S}) where {S}
_is_convertible_Int(Integer)
_promote(Real, Integer)
_promote(Real, Real)
iterate(Core.Compiler.Iterators.Zip2{_, _} where _ where _)
iterate(Core.Compiler.Iterators.Zip2{_, _} where _ where _, Tuple{Any, Any})
promote_type(Type{Int64}, Type{S}) where {S}
promote_type(Type{Int64}, Type{#s55} where #s55<:Integer)
promote_type(Type{T}, Type{Int64}) where {T}
promote_type(Type{#s55} where #s55<:Integer, Type{Int64})
pointer(Array{Any, 1}, Integer)
checkbounds(Type{Bool}, Core.Compiler.LinearIndices{1, Tuple{Core.Compiler.OneTo{Int64}}}, AbstractArray{Bool, 1})
_promote(Integer, Real)
checkbounds(Type{Bool}, AbstractArray{#s55, N} where #s55, AbstractArray{Bool, N}) where {N}
promote_type(Type{Int64}, Type{S} where S<:Real)
_promote(Int64, Real)
iterate(Core.Compiler.Iterators.Zip2{Core.Compiler.UnitRange{Int64}, _} where _)
iterate(Core.Compiler.Iterators.Zip2{Core.Compiler.UnitRange{Int64}, _} where _, Tuple{Int64, Any})
ntuple(getfield(Core.Compiler, Symbol("##65#66")){_} where _, Core.Compiler.Val{3})
axes(Array{Core.LineInfoNode, N} where N)
pointer(Array{Core.LineInfoNode, N} where N, Int64)
pointer(Array{T, N} where N where T, Int64)
lerpi(Int64, Int64, T, T) where {T}
iterate(Core.Compiler.OrdinalRange{Any, S} where S, Tuple{Core.Compiler.OneTo{_} where _})
iterate(Core.Compiler.OrdinalRange{Any, S} where S, Any)
iterate(Core.Compiler.Iterators.Enumerate{_} where _, Tuple{Int64})
iterate(Core.Compiler.Iterators.Enumerate{_} where _, Tuple{Int64})
promote_type(Type{T} where T<:Real, Type{Int64})
_promote(Real, Int64)
get_chunks_id(Integer)
_promote(Integer, Int64)
promote_type(Type{T} where T<:Unsigned, Type{UInt64})
_promote(Unsigned, UInt64)
<<(UInt64, Integer)
setindex!(Array{Int64, 1}, Int64, Any)
setindex!(Array{Core.Compiler.NewNode, 1}, Core.Compiler.NewNode, Any)
iterate(Core.Compiler.Iterators.Enumerate{_} where _, Tuple{Int64, Any})
in(Integer, Core.Compiler.BitSet)
setindex!(Array{Any, 1}, Nothing, Any)
setindex!(Array{Any, 1}, Core.SSAValue, Any)
setindex!(Array{Any, 1}, Core.Compiler.UndefToken, Any)
checkbounds(Array{T, N} where N where T, Int64)
_setindex!(Core.Compiler.IndexLinear, Array{T, N} where N where T, Core.SSAValue, Int64)
setindex!(Array{T, N} where N where T, Core.SSAValue, Any)
promote_type(Type{T} where T<:Real, Type{UInt64})
_promote(Real, UInt64)
isassigned(Array{T, N} where N where T, Int64)
_setindex!(Core.Compiler.IndexLinear, Array{T, N} where N where T, Type{Any}, Int64)
setindex!(Array{T, N} where N where T, Type{Any}, Any)
iterate(Core.Compiler.OrdinalRange{Core.LineInfoNode, S} where S, Tuple{Core.Compiler.OneTo{_} where _})
iterate(Core.Compiler.OrdinalRange{Core.LineInfoNode, S} where S, Tuple{Core.Compiler.OneTo{_} where _, Any})
iterate(Core.Compiler.OneTo{_} where _, Any)
_setindex!(Core.Compiler.IndexLinear, Array{T, N} where N where T, Type{T} where T, Int64)
setindex!(Array{T, N} where N where T, Type{T} where T, Any)
pointer(Array{T, 0} where T, Int64)
pointer(Array{T, N} where N where T, Integer)
pointer(Array{T, 1} where T, Int64)
axes(Array{Bool, N} where N)
pointer(Array{Bool, N} where N, Int64)
checkbounds(Core.Compiler.BitArray{N} where N, Int64)
setindex!(Core.Compiler.BitArray{N} where N, Any, Int64)
setindex!(AbstractArray{T, N} where N where T, Any, Int64)
pointer(Array{T, 1} where T, Integer)
iterate(Core.Compiler.Iterators.Zip2{Array{Int64, 1}, _} where _)
iterate(Core.Compiler.Iterators.Zip2{Array{Int64, 1}, _} where _, Tuple{Int64, Any})
promote_type(Type{T}, Type{Bool}) where {T}
promote_type(Type{T} where T<:Number, Type{Bool})
_promote(Number, Bool)
iterate(Core.Compiler.OrdinalRange{Tuple{Core.SlotNumber, Core.Compiler.NewSSAValue, Core.PhiCNode}, S} where S, Tuple{Core.Compiler.OneTo{_} where _})
iterate(Core.Compiler.OrdinalRange{Tuple{Core.SlotNumber, Core.Compiler.NewSSAValue, Core.PhiCNode}, S} where S, Tuple{Core.Compiler.OneTo{_} where _, Any})
iterate(Core.Compiler.OrdinalRange{Tuple{Core.SlotNumber, Core.Compiler.NewSSAValue, Core.PhiCNode}, S} where S, Tuple{Core.SlotNumber, Core.Compiler.NewSSAValue, Core.PhiCNode})
selectpivot!(Array{Int64, 1}, Int64, Int64, Core.Compiler.Order.By{_} where _)
selectpivot!(Array{Int64, 1}, Int64, Int64, Core.Compiler.Order.Lt{_} where _)
_tuple_any(Function, Bool, Any, Any...)
_tuple_any(Function, Bool, Core.Compiler.OneTo{Int64})
_tuple_any(Function, Bool, Core.Compiler.OneTo{Int64})
promote_type(Type{#s55} where #s55<:Integer, Type{Bool})
promote_type(Type{UInt64}, Type{S}) where {S}
promote_type(Type{Bool}, Type{S}) where {S}
promote_type(Type{Bool}, Type{#s55} where #s55<:Integer)
promote_type(Type{Int64}, Type{S}) where {S}
promote_type(Type{Int64}, Type{S} where S<:Real)
_promote(Int64, Real)
promote_type(Type{T}, Type{Int64}) where {T}
promote_type(Type{#s55} where #s55<:Integer, Type{Int64})
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
popfirst!(Base.Iterators.Stateful{_, _} where _ where _)
promote_type(Type{T}, Type{UInt64}) where {T}
promote_type(Type{T}, Type{UInt8}) where {T}
promote_type(Type{#s55} where #s55<:Integer, Type{UInt8})
promote_type(Type{T} where T<:Unsigned, Type{UInt64})
_promote(Unsigned, UInt64)
promote_type(Type{#s55} where #s55<:Integer, Type{Bool})
promote_type(Type{Int64}, Type{S} where S<:Integer)
_promote(Int64, Integer)
iterate(Array{Base.Padding, 1}, Any)
popfirst!(Base.Iterators.Stateful{Base.CyclePadding{Array{Base.Padding, 1}}, Any})
_promote(Integer, Int64)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
promote_type(Type{Tuple{Tuple{Symbol}, UnionAll, UnionAll}}, Type{S}) where {S}
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
iterate(Base.Iterators.Zip2{_, _} where _ where _)
iterate(Base.Iterators.Zip2{_, _} where _ where _, Tuple{Any, Any})
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
>>(UInt16, Integer)
>>(UInt32, Integer)
>>(UInt64, Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Iterators.Reverse{_} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Iterators.Reverse{_} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.Iterators.Reverse{String}, Union{Nothing, Tuple{Char, Int64}}}} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.Iterators.Reverse{String}, Union{Nothing, Tuple{Char, Int64}}}} where _, Tuple{Any, Nothing})
pointer(Array{T, 1} where T, Int64)
promote_type(Type{T} where T<:Signed, Type{Int64})
_promote(Signed, Int64)
size(Array{T, N} where N where T)
pointer(Array{T, N} where N where T, Int64)
promote_type(Type{#s55} where #s55<:Integer, Type{UInt64})
size(Array{Bool, N} where N)
axes(Array{Bool, N} where N)
pointer(Array{Bool, N} where N, Int64)
try_bool_conversion(Real)
promote_type(Type{UInt64}, Type{#s55} where #s55<:Integer)
_iterate(Base.Dict{Any, _} where _, Int64)
_setindex!(Base.Dict{WeakRef, V} where V, Any, WeakRef, Int64)
_is_convertible_Int(Integer)
promote_type(Type{T} where T<:Real, Type{Int64})
_promote(Real, Int64)
_setindex!(Base.Dict{K, Nothing} where K, Nothing, Any, Int64)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.Pair{_, _}})(Any, Any)
isspace(AbstractChar)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Integer, Int64)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{_} where _, Int64, Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
broadcasted(typeof(Base.:(+)), Any, Int64)
tuplebroadcast(Tuple{Vararg{Any, N}}, Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Axes, F, Args} where Args<:Tuple where F where Axes) where {N}
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Integer, Integer)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Base.UnitRange{#s57} where #s57<:Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
_promote(Int64, AbstractFloat)
axes(Array{Any, 1}, Any)
broadcasted(typeof(Base.:(+)), Any, Any)
_cat_t(Int64, Type{Any}, Array{Any, 1}, Array{Any, 1}...)
_cat_t(Int64, Type{T} where T, Array{Any, 1}, Array{Any, 1}...)
_setindex!(Base.Dict{Symbol, _} where _, Any, Symbol, Int64)
_setindex!(Base.Dict{K, V} where V where K<:Symbol, Any, Symbol, Int64)
_setindex!(Base.Dict{K, V} where V where K, Any, Any, Int64)
_iterate(Base.Dict{Symbol, _} where _, Int64)
_iterate(Base.Dict{_, _} where _ where _, Int64)
(::Type{Base.Pair{_, _}})(Type{T} where T, Type{T} where T)
broadcasted(typeof(Base.Docs.tvar), Any)
tuplebroadcast(Tuple{Vararg{Any, N}}, Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, _, typeof(Base.Docs.tvar), _} where _<:Tuple where _) where {N}
pointer(Array{Any, 1}, Integer)
_promote(Integer, Real)
iterate(Base.Iterators.Zip2{Base.UnitRange{Int64}, _} where _)
iterate(Base.Iterators.Zip2{Base.UnitRange{Int64}, _} where _, Tuple{Int64, Any})
promote_type(Type{Any}, Type{S}) where {S}
promote_type(Type{Expr}, Type{S}) where {S}
promote_type(Type{Nothing}, Type{S}) where {S}
promote_typeof(Nothing, Expr, Any, Bool)
promote_type(Type{Symbol}, Type{S}) where {S}
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
promote_typeof(Nothing, Any, Any, Bool)
_setindex!(Base.Dict{K, V} where V where K<:Union{Int64, String, Symbol}, Any, Int64, Int64)
_setindex!(Base.Dict{K, V} where V where K<:Union{Int64, String, Symbol}, Any, String, Int64)
_setindex!(Base.Dict{K, V} where V where K<:Union{Int64, String, Symbol}, Any, Symbol, Int64)
_promote(AbstractFloat, Int64)
tuplebroadcast(Tuple{Vararg{Any, N}}, Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, _, typeof(Base.:(*)), _} where _<:Tuple where _) where {N}
promote_type(Type{T}, Type{Any}) where {T}
promote_type(Type{T}, Type{Symbol}) where {T}
pointer(Array{String, 1}, Integer)
#s57#303(Any, Any, Any, Any, Any)
size(Array{String, N} where N)
axes(Array{String, N} where N)
isassigned(Array{String, N} where N, Int64)
axes(Array{String, N} where N, Any)
axes(Array{String, N} where N, Int64)
axes(Array{String, N} where N, Int64)
axes(Array{String, N} where N, Int64)
_promote(Real, Integer)
_iterate(Base.Dict{WeakRef, _} where _, Int64)
(::Type{Base.SubArray{_, _, _, _, false}})(AbstractArray{T, N} where N where T, Tuple, Int64, Int64)
(::Type{Base.SubArray{_, _, _, _, false}})(AbstractArray{T, N} where N where T, Tuple, Int64, Int64)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexCartesian, AbstractArray{T, N} where N where T, Tuple, Tuple{Vararg{Any, N}}) where {N}
compute_stride1(AbstractArray{T, N} where N where T, Tuple)
compute_offset1(AbstractArray{T, 1} where T, Integer, Tuple{Base.AbstractRange{T} where T})
(::Type{Base.SubArray{_, _, _, _, true}})(AbstractArray{T, N} where N where T, Tuple, Any, Any)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexLinear, AbstractArray{T, N} where N where T, Tuple, Tuple{Vararg{Any, N}}) where {N}
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(AbstractArray{T, N} where N where T, Tuple)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(AbstractArray{T, N} where N where T, Tuple)
(::Type{Base.SubArray{_, _, _, _, false}})(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple, Int64, Int64)
(::Type{Base.SubArray{_, _, _, _, false}})(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple, Int64, Int64)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexCartesian, Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple, Tuple)
compute_stride1(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple)
compute_offset1(Base.SubArray{T, 1, P, I, L} where L where I where P where T, Integer, Tuple{Base.AbstractRange{T} where T})
(::Type{Base.SubArray{_, _, _, _, true}})(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple, Any, Any)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexLinear, Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple, Tuple)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple{Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple{Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(AbstractArray{T, N} where N where T, Tuple{Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(AbstractArray{T, N} where N where T, Tuple{Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
length(Base.SubArray{T, 2, P, I, L} where L where I where P where T)
checkbounds_indices(Type{Bool}, Tuple, Tuple{Int64})
checkbounds_indices(Type{Bool}, Tuple, Tuple{Int64, Int64})
checkbounds(Base.SubArray{T, 2, P, I, false} where I where P where T, Int64, Int64)
getindex(Base.SubArray{T, 2, P, I, false} where I where P, Int64, Int64) where {T}
checkbounds(Base.SubArray{T, 0, P, I, false} where I where P where T)
getindex(Base.SubArray{T, 0, P, I, false} where I where P) where {T}
_cshp(Int64, Tuple{Bool}, Tuple{Any, Vararg{Any, N} where N}, Tuple)
axes(Base.StepRange{Char, Int64}, Any)
genperm(Tuple{Vararg{Any, N}}, Tuple{Vararg{Int64, N}}) where {N}
axes(AbstractArray{Char, N} where N, Any)
_cat_t(Base.Val{1}, Type{Char}, Base.StepRange{Char, Int64}, Base.StepRange{Char, Int64}, Base.StepRange{Char, Int64}, AbstractArray{Char, N} where N...)
_cat_t(Base.Val{1}, Type{Char}, Base.StepRange{Char, Int64}, AbstractArray{Char, N} where N...)
promote_type(Type{Char}, Type{S}) where {S}
axes(AbstractArray{T, N} where N where T, Any)
size(Base.BitArray{1}, Any)
(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(AbstractArray{T, N} where N where T, Tuple)
_maybe_reindex(Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Tuple{Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N}, Tuple{})
view(AbstractArray{T, N} where N where T, Base.UnitRange{Int64}...) where {N}
get_chunks_id(Integer)
_cat_t(Base.Val{1}, Type{T} where T, Base.StepRange{Char, Int64}, Any...)
_cat_t(Base.Val{1}, Type{Char}, Base.StepRange{Char, Int64}, Any...)
_cat_t(Base.Val{1}, Type{T} where T, Base.StepRange{Char, Int64}, Any...)
axes(AbstractArray{T, N} where N where T, Int64)
broadcasted(typeof(Base.:(+)), Int64, Any)
size(Array{Char, N} where N)
axes(Array{Char, N} where N)
pointer(Array{Char, N} where N, Int64)
setindex!(Array{Char, 1}, Array{Char, N} where N, Base.UnitRange{Int64})
_tuple_any(getfield(Base, Symbol("##83#84")), Bool, Any, Any...)
setindex!(Array{Char, 1}, AbstractArray{T, N} where N where T, Base.UnitRange{Int64})
axes(Array{String, N} where N, Int64)
axes(Array{String, N} where N, Int64)
view(Array{String, N} where N, Any, Any, Any...)
promote_type(Type{String}, Type{S}) where {S}
promote_typeof(Nothing, String, Any, Bool)
promote_type(Type{Tuple{Symbol, Nothing, Symbol, Symbol}}, Type{S}) where {S}
promote_type(Type{Tuple{Symbol, Expr, Symbol, Symbol}}, Type{S}) where {S}
promote_type(Type{Tuple{Symbol, Symbol, Symbol, Symbol}}, Type{S}) where {S}
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Integer, Int64)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{_} where _, Int64, Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Integer, Integer)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Base.UnitRange{#s57} where #s57<:Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
isvalid(AbstractString, Integer)
(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Integer, Int64)
getindex(Array{_, 1} where _, Base.UnitRange{Int64})
axes(AbstractArray{#s576, 1} where #s576<:Union{Float32, Float64}, Int64)
axes(AbstractArray{T, 1} where T, Int64)
selectpivot!(AbstractArray{#s576, 1} where #s576<:Union{Float32, Float64}, Int64, Int64, Base.Sort.Float.Left)
selectpivot!(AbstractArray{#s576, 1} where #s576<:Union{Float32, Float64}, Int64, Int64, Base.Sort.Float.Right)
selectpivot!(AbstractArray{T, 1} where T, Int64, Int64, Base.Order.ForwardOrdering)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.SubString{_} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.SubString{_} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
_setindex!(Base.Dict{K, V} where V where K<:Distributed.RRID, Any, Distributed.RRID, Int64)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
_promote(AbstractFloat, UInt64)
isassigned(Array{T, N} where N where T, Int64)
_setindex!(Base.Dict{K, V} where V where K<:Base.Pair{Any, Any}, Any, Base.Pair{Any, Any}, Int64)
_iterate(Base.Dict{T, Nothing} where T, Int64)
delete!(Base.BitSet, Integer)
iterate(Base.KeySet{#s54, #s53} where #s53<:(Base.Dict{K, V} where V where K) where #s54, Any)
setindex!(Base.BitArray{1}, Any, Int64)
setindex!(Base.BitArray{1}, Any, Int64)
_chkstride1(Bool, AbstractArray{Float64, 2}, Array{Float64, 1})
_chkstride1(Bool, AbstractArray{Float64, 2}, Array{Float64, 1})
_chkstride1(Bool, AbstractArray{Float32, 2}, Array{Float32, 1})
_chkstride1(Bool, AbstractArray{Float32, 2}, Array{Float32, 1})
_chkstride1(Bool, AbstractArray{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 1})
_chkstride1(Bool, AbstractArray{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 1})
_chkstride1(Bool, AbstractArray{Base.Complex{Float32}, 2}, Array{Base.Complex{Float32}, 1})
_chkstride1(Bool, AbstractArray{Base.Complex{Float32}, 2}, Array{Base.Complex{Float32}, 1})
eachindex(Array{Bool, N} where N)
checkbounds(Type{Bool}, Base.BitArray{1}, Base.LogicalIndex{Int64, _} where _<:AbstractArray{Bool, 1})
_getindex(Base.IndexLinear, Base.BitArray{1}, Base.LogicalIndex{Int64, _} where _)
getindex(Base.BitArray{1}, Array{Bool, N} where N)
pointer(Array{T, 1} where T<:Integer, Int64)
_allocres(Tuple{Int64}, Type{Ti} where Ti<:Integer, Type{T} where T, Int64)
colboundind(SparseArrays.SparseVector{Tv, Ti} where Ti<:Integer where Tv, Int64)
colboundind(SparseArrays.SparseVector{Tv, Ti} where Ti<:Integer where Tv, Int64)
_rowforind(Int64, Any, Any, SparseArrays.SparseVector{Tv, Ti} where Ti<:Integer where Tv)
_fusedupdate(Int64, Real, Any, Any, Any, SparseArrays.SparseVector{Tv, Ti} where Ti<:Integer where Tv)
setindex!(Array{Tv, 1} where Tv, Bool, Any)
iterate(Base.ValueIterator{#s52} where #s52<:(Base.Dict{K, V} where V where K), Any)
promote_type(Type{Base.Regex}, Type{S}) where {S}
promote_type(Type{typeof(Pkg.Types.semver_interval)}, Type{S}) where {S}
promote_type(Type{Base.Pair{Base.Regex, typeof(Pkg.Types.semver_interval)}}, Type{S}) where {S}
promote_type(Type{Bool}, Type{S}) where {S}
promote_type(Type{Base.Pair{Symbol, Bool}}, Type{S}) where {S}
promote_type(Type{Tuple{Array{String, 1}, Pkg.REPLMode.OptionClass, Base.Pair{Symbol, Pkg.Types.PackageMode}}}, Type{S}) where {S}
unique_from(AbstractArray{T, N} where N where T, Array{_, 1} where _, Base.Set{_} where _, Any)
getindex(DataType, Any)
unique_from(Any, Array{_, 1} where _, Base.Set{_} where _, Any)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
pointer(Array{T, 1} where T, Int64)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
axes(Array{String, N} where N, Int64)
axes(Array{String, N} where N, Int64)
pointer(Array{T, N} where N where T, Int64)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Iterators.Reverse{_} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.Iterators.Reverse{String}, Union{Nothing, Tuple{Char, Int64}}}} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.Iterators.Reverse{String}, Union{Nothing, Tuple{Char, Int64}}}} where _, Tuple{Any, Nothing})
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Integer, Int64)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{_} where _, Int64, Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Integer, Integer)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Base.UnitRange{#s57} where #s57<:Integer)
unique_from(AbstractArray{T, N} where N where T, Array{_, 1} where _, Base.Set{_} where _, Any)
unique_from(Any, Array{_, 1} where _, Base.Set{_} where _, Any)
_cshp(Int64, Tuple{Bool}, Tuple{Int64}, Tuple)
_cat_t(Int64, Type{Any}, Array{Any, 1}, Any...)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
promote_type(Type{Tuple{Tuple{Symbol}, UnionAll, UnionAll}}, Type{S}) where {S}
promote_type(Type{DataType}, Type{S}) where {S}
promote_typeof(Type{Float64}, Type{Real}, Type{Base.Complex{T} where T<:Real}, Type{Base.Rational{T} where T<:Integer})
promote_typeof(Type{Base.GMP.BigInt}, Type{Float32}, Type{Float64}, Type{Real}, Type{Base.Complex{T} where T<:Real}, Type{Base.Rational{T} where T<:Integer})
promote_typeof(Type{Signed}, Type{Integer}, Type{Base.GMP.BigInt}, Type{Float32}, Type{Float64}, Type{Real}, Type{Base.Complex{T} where T<:Real}, Type{Base.Rational{T} where T<:Integer})
size(Array{Any, N} where N)
axes(Array{Any, N} where N)
pointer(Array{Any, N} where N, Int64)
setindex!(Array{Any, 1}, Array{Any, N} where N, Base.UnitRange{Int64})
setindex!(Array{Any, 1}, AbstractArray{T, N} where N where T, Base.UnitRange{Int64})
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
_promote(Any, Any)
unsafe_getindex(Base.StepRangeLen{Int64, R, S} where S<:(Base.TwicePrecision{T} where T) where R<:(Base.TwicePrecision{T} where T), Int64)
iterate(Base.AbstractUnitRange{T} where T, Tuple{Union{Base.OneTo{_} where _, Base.Slice{T} where T<:(Base.AbstractUnitRange{T} where T)}})
iterate(Base.OrdinalRange{Int64, S} where S, Tuple{Union{Base.OneTo{_} where _, Base.Slice{T} where T<:(Base.AbstractUnitRange{T} where T)}})
iterate(Base.AbstractUnitRange{T} where T, Any)
iterate(Base.OrdinalRange{Int64, S} where S, Any)
#s57#303(Any, Any, Any, Any, Any)
promote_type(Type{Tuple{String, Pkg.REPLMode.OptionClass, Base.Pair{Symbol, Pkg.Types.UpgradeLevel}}}, Type{S}) where {S}
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.Generator{_, getfield(Base, Symbol("##5#6")){Base.Pair{A, B} where B where A}} where _)
_cat_t(Int64, Type{Any}, Array{Any, 1}, Union{Array{Any, 1}, Array{Any, 2}, LinearAlgebra.Adjoint{Any, Array{Any, 1}}, LinearAlgebra.Transpose{Any, Array{Any, 1}}, LinearAlgebra.AbstractTriangular{Any, A} where A<:(Array{T, 2} where T), LinearAlgebra.Hermitian{Any, A} where A<:(Array{T, 2} where T), LinearAlgebra.Symmetric{Any, A} where A<:(Array{T, 2} where T)}...)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Int64, Integer)
(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Integer, Int64)
(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Integer, Integer)
(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Base.UnitRange{#s57} where #s57<:Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
_check_bitset_bounds(Integer)
setindex!(Core.Compiler.BitArray{1}, Any, Int64)
get_chunks_id(Integer)
in(Integer, Core.Compiler.BitSet)
isassigned(Array{T, N} where N where T, Int64)
pointer(Array{T, 0} where T, Int64)
pointer(Array{T, N} where N where T, Int64)
promote_type(Type{T}, Type{Base.SubstitutionString{String}}) where {T}
_iterate(Base.Dict{String, _} where _, Int64)
_setindex!(Base.Dict{K, String} where K, String, Any, Int64)
_iterate(Base.Dict{_, String} where _, Int64)
iterate(Base.Iterators.Enumerate{_} where _, Tuple{Int64})
iterate(Base.Iterators.Enumerate{_} where _, Tuple{Int64})
iterate(Base.Iterators.Enumerate{_} where _, Tuple{Int64, Any})
selectpivot!(AbstractArray{T, 1} where T, Int64, Int64, Base.Order.By{getfield(Pkg.Types, Symbol("##68#75"))})
_setindex!(Base.Dict{K, V} where V where K<:Base.Pair{String, Any}, Any, Base.Pair{String, Any}, Int64)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
lt(Base.Order.Perm{_, Array{Tuple{Float64, Int64}, 1}} where _<:Base.Order.Ordering, Int64, Int64)
selectpivot!(Array{Int64, 1}, Int64, Int64, Base.Order.Perm{_, Array{Tuple{Float64, Int64}, 1}} where _)
promote_type(Type{T}, Type{String}) where {T}
pointer(Array{Base.Dict{Any, Any}, 1}, Integer)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{String, Union{Nothing, Tuple{Char, Int64}}}} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{String, Union{Nothing, Tuple{Char, Int64}}}} where _, Tuple{Any, Nothing})
get_chunks_id(Integer)
promote_type(Type{T} where T<:Unsigned, Type{UInt64})
_promote(Unsigned, UInt64)
<<(UInt64, Integer)
setindex!(Array{Any, 1}, Ptr{Nothing}, Any)
promote_type(Type{T}, Type{UInt32}) where {T}
length(Base.SubArray{UInt8, 1, P, I, L} where L where I where P)
_setindex!(Base.Dict{K, Int64} where K, Int64, Any, Int64)
_iterate(Base.Dict{_, Int64} where _, Int64)
view(Array{Tv, 1} where Tv, Any)
checkbounds(Base.SubArray{T, 1, P, I, false} where I where P where T, Int64)
getindex(Base.SubArray{T, 1, P, I, false} where I where P, Int64) where {T}
_setindex!(Base.Dict{K, Pkg.GraphType.ResolveLogEntry} where K, Pkg.GraphType.ResolveLogEntry, Any, Int64)
_iterate(Base.Dict{_, Pkg.GraphType.ResolveLogEntry} where _, Int64)
checkbounds_indices(Type{Bool}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Tuple{Base.LogicalIndex{Int64, Base.BitArray{1}}, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
selectpivot!(Array{_, 1} where _, Int64, Int64, Base.Order.By{getfield(Pkg.GraphType, Symbol("##52#54")){Pkg.GraphType.ResolveLog}})
_setindex!(Base.Dict{K, V} where V where K<:String, Any, String, Int64)
selectpivot!(AbstractArray{T, 1} where T, Int64, Int64, Base.Order.By{typeof(Base.Unicode.lowercase)})
iterate(Base.Iterators.Pairs{K, V, I, A} where A where I where V where K)
iterate(Base.Iterators.Pairs{K, V, I, A} where A where I where V where K, Any)
selectpivot!(Array{String, 1}, Int64, Int64, Base.Order.Ordering)
selectpivot!(AbstractArray{#s576, 1} where #s576<:Union{Float32, Float64}, Int64, Int64, Base.Order.ForwardOrdering)
selectpivot!(AbstractArray{#s576, 1} where #s576<:Union{Float32, Float64}, Int64, Int64, Base.Order.ReverseOrdering{Base.Order.ForwardOrdering})
lt(Base.Order.Perm{#s576, #s575} where #s575<:(Array{#s574, 1} where #s574<:Union{Float32, Float64}) where #s576<:Union{Base.Order.ForwardOrdering, Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}}, Int64, Int64)
selectpivot!(Array{Int64, 1}, Int64, Int64, Base.Order.Perm{#s576, #s575} where #s575<:(Array{#s574, 1} where #s574<:Union{Float32, Float64}) where #s576<:Union{Base.Order.ForwardOrdering, Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}})
lt(Base.Order.Perm{Base.Sort.Float.Left, _} where _<:(AbstractArray{T, 1} where T), Int64, Int64)
selectpivot!(Array{Int64, 1}, Int64, Int64, Base.Order.Perm{Base.Sort.Float.Left, _} where _)
lt(Base.Order.Perm{Base.Sort.Float.Right, _} where _<:(AbstractArray{T, 1} where T), Int64, Int64)
selectpivot!(Array{Int64, 1}, Int64, Int64, Base.Order.Perm{Base.Sort.Float.Right, _} where _)
selectpivot!(AbstractArray{T, 1} where T, Int64, Int64, Base.Order.Ordering)
promote_type(Type{T}, Type{Char}) where {T}
(::Type{Base.Pair{_, _}})(Base.Pair{_, _} where _ where _, Base.Pair{_, _} where _ where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.SubString{_} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.SubString{_} where _)
(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{_} where _, Integer, Int64)
setindex!(Array{T, 1} where T, UInt8, Integer)
setindex!(Array{T, 1} where T, UInt8, Any)
promote_type(Type{Float64}, Type{S} where S<:Real)
_promote(Float64, Real)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
iterate(Base.Iterators.Zip2{Base.Iterators.Stateful{String, Union{Nothing, Tuple{Char, Int64}}}, _} where _)
iterate(Base.Iterators.Zip2{Base.Iterators.Stateful{String, Union{Nothing, Tuple{Char, Int64}}}, _} where _, Tuple{Nothing, Any})
read(Base.GenericIOBuffer{T} where T<:AbstractArray{UInt8, 1}, Type{UInt8})
unique_from(Array{Any, 1}, Array{_, 1} where _, Base.Set{_} where _, Int64)
unique_from(Array{Any, 1}, Array{Any, 1}, Base.Set{Any}, Int64)
iterate(Base.Iterators.Zip2{_, Core.SimpleVector} where _)
iterate(Base.Iterators.Zip2{_, Core.SimpleVector} where _, Tuple{Any, Int64})
broadcasted(typeof(Base.:(+)), Any, Int64)
getindex(Array{String, 1}, Integer, Integer)
to_indices(Array{String, 1}, Tuple{}, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}})
to_indices(Array{String, 1}, Tuple{}, Tuple{Integer, Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}})
checkindex(Type{Bool}, Base.OneTo{Int64}, Base.AbstractRange{Base.IteratorsMD.CartesianIndex{N}} where N)
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N}) where {N}
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N, Vararg{AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N where N, N} where N}) where {N}
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{Vararg{AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N where N, N} where N})
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N}) where {N}
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
checkbounds_indices(Type{Bool}, Tuple{Base.OneTo{Int64}}, Tuple{Int64, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N} where N})
checkbounds(Array{T, N} where N where T, Base.UnitRange{Int64})
setindex!(Array{T, N} where N, Array{T, 1}, Base.UnitRange{Int64}) where {T}
setindex!(Array{T, N} where N where T, Array{T, 1} where T, Base.UnitRange{Int64})
to_indices(Array{T, N} where N where T, Any, Tuple{Base.UnitRange{Int64}, Base.Colon})
to_indices(Array{T, N} where N where T, Tuple{Base.UnitRange{Int64}, Base.Colon})
checkindex(Type{Bool}, Base.OneTo{Int64}, Base.Slice{_} where _)
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{Base.Slice{_} where _})
checkbounds_indices(Type{Bool}, Tuple{}, Tuple{Base.UnitRange{Int64}, Base.Slice{_} where _})
checkbounds(Type{Bool}, Array{T, N} where N where T, Base.UnitRange{Int64}, Base.Slice{_} where _)
_setindex!(Base.IndexLinear, Array{T, N} where N where T, Array{T, 1} where T, Base.UnitRange{Int64}, Base.Slice{_} where _)
setindex!(Array{T, N} where N where T, Array{T, 1} where T, Base.UnitRange{Int64}, Base.Colon)
axes(Array{Symbol, 1}, Any)
axes(Array{T, 1} where T, Any)
_cat_t(Base.Val{1}, Type{T} where T, Array{Symbol, 1}, Array{Symbol, 1}, Array{Symbol, 1}, Array{T, 1} where T...)
setindex!(Array{Any, 1}, String, Any)
setindex!(Array{_, 1} where _, Array{String, 1}, Base.UnitRange{Int64})
setindex!(Array{T, 1}, Array{T, 1}, Base.UnitRange{Int64}) where {T}
setindex!(Array{_, 1} where _, Array{_, 1} where _, Base.UnitRange{Int64})
_cat_t(Base.Val{1}, Type{T} where T, Array{String, 1}, Array{_, 1} where _)
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(Base.SubString{_} where _)
setindex!(Array{UInt8, 1}, UInt8, Any)
checkindex(Type{Bool}, Base.OneTo{Int64}, Base.UnitRange{#s56} where #s56<:Integer)
checkbounds(Array{UInt8, 1}, Base.UnitRange{#s56} where #s56<:Integer)
length(Base.UnitRange{T<:Int64}) where {T<:Int64}
getindex(Array{UInt8, 1}, Base.UnitRange{#s56} where #s56<:Integer)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.Iterators.Rest{String, Int64}, Union{Nothing, Tuple{Char, Int64}}}} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.Iterators.Rest{String, Int64}, Union{Nothing, Tuple{Char, Int64}}}} where _, Tuple{Any, Nothing})
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.SubString{String}, Union{Nothing, Tuple{Char, Int64}}}} where _)
iterate(Base.Iterators.Zip2{_, Base.Iterators.Stateful{Base.SubString{String}, Union{Nothing, Tuple{Char, Int64}}}} where _, Tuple{Any, Nothing})
_setindex!(Base.Dict{K, Nothing} where K<:REPL.REPLCompletions.Completion, Nothing, REPL.REPLCompletions.Completion, Int64)
unique_from(Array{REPL.REPLCompletions.Completion, 1}, Array{_, 1} where _, Base.Set{_} where _, Int64)
unique_from(Array{REPL.REPLCompletions.Completion, 1}, Array{REPL.REPLCompletions.Completion, 1}, Base.Set{REPL.REPLCompletions.Completion}, Int64)
selectpivot!(Array{_, 1} where _, Int64, Int64, Base.Order.By{typeof(REPL.REPLCompletions.completion_text)})
pointer(Array{T, 1} where T<:Real, Int64)
pointer(Array{T, 1} where T<:AbstractString, Int64)
pointer(Array{T, 1} where T<:Symbol, Int64)
_setindex!(Base.Dict{K, Nothing} where K<:Real, Nothing, Real, Int64)
_setindex!(Base.Dict{K, Nothing} where K<:AbstractString, Nothing, AbstractString, Int64)
_setindex!(Base.Dict{K, Nothing} where K<:Symbol, Nothing, Symbol, Int64)
iterate(Base.Iterators.Zip2{Base.OneTo{Int64}, _} where _)
iterate(Base.Iterators.Zip2{Base.OneTo{Int64}, _} where _, Tuple{Int64, Any})
iterate(Base.Iterators.Zip2{Array{Char, 1}, _} where _)
iterate(Base.Iterators.Zip2{Array{Char, 1}, _} where _, Tuple{Int64, Any})
(::Type{Base.Iterators.Stateful{T, VS} where VS where T})(AbstractString)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment