From f5c5109955fd3a3729cc4fd8461da67b5102b478 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Mon, 8 Jan 2018 13:36:46 -0600 Subject: [PATCH] Rename endof->endindex and introduce beginindex. Fixes #23354 --- NEWS.md | 6 +++ base/abstractarray.jl | 23 ++++++++--- base/array.jl | 8 ++-- base/char.jl | 3 +- base/deprecated.jl | 11 ++++-- base/dict.jl | 2 +- base/essentials.jl | 3 +- base/exports.jl | 3 +- base/gmp.jl | 4 +- base/int.jl | 4 +- base/io.jl | 4 +- base/markdown/parse/parse.jl | 3 +- base/namedtuple.jl | 3 +- base/number.jl | 3 +- base/pair.jl | 3 +- base/parse.jl | 12 +++--- base/precompile.jl | 8 ++-- base/printf.jl | 2 +- base/process.jl | 2 +- base/random/generation.jl | 6 +-- base/reduce.jl | 4 +- base/regex.jl | 6 +-- base/repl/LineEdit.jl | 18 ++++----- base/repl/REPL.jl | 10 ++--- base/repl/REPLCompletions.jl | 10 ++--- base/strings/basic.jl | 17 +++++---- base/strings/io.jl | 10 ++--- base/strings/search.jl | 20 +++++----- base/strings/substring.jl | 10 ++--- base/strings/util.jl | 24 ++++++------ base/subarray.jl | 12 +++--- base/tuple.jl | 3 +- doc/src/manual/functions.md | 3 +- doc/src/manual/interacting-with-julia.md | 2 +- doc/src/manual/interfaces.md | 11 ++++-- doc/src/manual/strings.md | 25 +++++++----- doc/src/manual/style-guide.md | 4 +- doc/src/stdlib/collections.md | 3 +- doc/src/stdlib/punctuation.md | 2 +- src/common_symbols2.inc | 2 +- src/julia-syntax.scm | 42 +++++++++++++-------- stdlib/Base64/src/buffer.jl | 5 ++- stdlib/Base64/src/decode.jl | 4 +- stdlib/Dates/src/io.jl | 4 +- stdlib/Dates/src/parse.jl | 8 ++-- stdlib/DelimitedFiles/src/DelimitedFiles.jl | 4 +- test/char.jl | 4 +- test/dict.jl | 6 +-- test/numbers.jl | 2 +- test/offsetarray.jl | 2 +- test/operators.jl | 4 +- test/parse.jl | 2 +- test/read.jl | 2 +- test/replcompletions.jl | 22 +++++------ test/strings/basic.jl | 18 ++++----- test/strings/search.jl | 40 ++++++++++---------- test/strings/types.jl | 10 ++--- test/tuple.jl | 6 +-- 58 files changed, 276 insertions(+), 218 deletions(-) diff --git a/NEWS.md b/NEWS.md index b512e2c1b363b..bc87cd65c27a9 100644 --- a/NEWS.md +++ b/NEWS.md @@ -43,6 +43,9 @@ New language features * Values for `Enum`s can now be specified inside of a `begin` block when using the `@enum` macro ([#25424]). + * `a[begin]` can now be used to address the first element of an integer-indexed collection `a`. + The index is computed by `beginindex(a)` ([#23554]). + Language changes ---------------- @@ -918,6 +921,8 @@ Deprecated or removed * `findin(a, b)` has been deprecated in favor of `find(occursin(b), a)` ([#24673]). + * `endof(a)` has been renamed `endindex(a)` ([#23554]). + Command-line option changes --------------------------- @@ -1074,6 +1079,7 @@ Command-line option changes [#23323]: https://github.com/JuliaLang/julia/issues/23323 [#23341]: https://github.com/JuliaLang/julia/issues/23341 [#23342]: https://github.com/JuliaLang/julia/issues/23342 +[#23354]: https://github.com/JuliaLang/julia/issues/23354 [#23366]: https://github.com/JuliaLang/julia/issues/23366 [#23373]: https://github.com/JuliaLang/julia/issues/23373 [#23404]: https://github.com/JuliaLang/julia/issues/23404 diff --git a/base/abstractarray.jl b/base/abstractarray.jl index be993d85e66fd..a5e1f8636a6f9 100644 --- a/base/abstractarray.jl +++ b/base/abstractarray.jl @@ -146,7 +146,7 @@ ndims(::Type{T}) where {T<:AbstractArray} = ndims(supertype(T)) Return the number of elements in the collection. -Use [`endof`](@ref) to get the last valid index of an indexable collection. +Use [`endindex`](@ref) to get the last valid index of an indexable collection. # Examples ```jldoctest @@ -165,17 +165,30 @@ _length(A::AbstractArray) = (@_inline_meta; prod(map(unsafe_length, axes(A)))) # _length(A) = (@_inline_meta; length(A)) """ - endof(collection) -> Integer + endindex(collection) -> Integer Return the last index of the collection. # Examples ```jldoctest -julia> endof([1,2,4]) +julia> endindex([1,2,4]) 3 ``` """ -endof(a::AbstractArray) = (@_inline_meta; last(linearindices(a))) +endindex(a::AbstractArray) = (@_inline_meta; last(linearindices(a))) + +""" + beginindex(collection) -> Integer + +Return the first index of the collection. + +# Examples +```jldoctest +julia> beginindex([1,2,4]) +1 +``` +""" +beginindex(a::AbstractArray) = (@_inline_meta; first(linearindices(a))) first(a::AbstractArray) = a[first(eachindex(a))] @@ -204,7 +217,7 @@ end last(coll) Get the last element of an ordered collection, if it can be computed in O(1) time. This is -accomplished by calling [`endof`](@ref) to get the last index. Return the end +accomplished by calling [`endindex`](@ref) to get the last index. Return the end point of an `AbstractRange` even if it is empty. # Examples diff --git a/base/array.jl b/base/array.jl index c94511aaf8304..e8f8b21d9a7f9 100644 --- a/base/array.jl +++ b/base/array.jl @@ -1512,7 +1512,7 @@ julia> findnext(A, 3) ``` """ function findnext(A, start::Integer) - l = endof(A) + l = endindex(A) i = start warned = false while i <= l @@ -1572,7 +1572,7 @@ julia> findnext(isodd, A, 2) ``` """ function findnext(testf::Function, A, start::Integer) - l = endof(A) + l = endindex(A) i = start while i <= l if testf(A[i]) @@ -1664,7 +1664,7 @@ julia> findlast(A) 0 ``` """ -findlast(A) = findprev(A, endof(A)) +findlast(A) = findprev(A, endindex(A)) """ findprev(predicate::Function, A, i::Integer) @@ -1715,7 +1715,7 @@ julia> findlast(x -> x > 5, A) 0 ``` """ -findlast(testf::Function, A) = findprev(testf, A, endof(A)) +findlast(testf::Function, A) = findprev(testf, A, endindex(A)) """ find(f::Function, A) diff --git a/base/char.jl b/base/char.jl index 717881c37d05c..a2621f77a78d5 100644 --- a/base/char.jl +++ b/base/char.jl @@ -70,7 +70,8 @@ size(c::Char,d) = convert(Int, d) < 1 ? throw(BoundsError()) : 1 ndims(c::Char) = 0 ndims(::Type{Char}) = 0 length(c::Char) = 1 -endof(c::Char) = 1 +beginindex(c::Char) = 1 +endindex(c::Char) = 1 getindex(c::Char) = c getindex(c::Char, i::Integer) = i == 1 ? c : throw(BoundsError()) getindex(c::Char, I::Integer...) = all(x -> x == 1, I) ? c : throw(BoundsError()) diff --git a/base/deprecated.jl b/base/deprecated.jl index 9e10f28c8e4ab..6cb6662b816f2 100644 --- a/base/deprecated.jl +++ b/base/deprecated.jl @@ -3871,9 +3871,9 @@ end @deprecate rsearch(s::AbstractString, r::Regex) findlast(r, s) @deprecate rsearch(s::AbstractString, c::Char, i::Integer) findprev(equalto(c), s, i) @deprecate rsearch(s::AbstractString, c::Char) findlast(equalto(c), s) -@deprecate rsearch(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = endof(a)) findprev(equalto(b), a, i) -@deprecate rsearch(a::String, b::Union{Int8,UInt8}, i::Integer = endof(a)) findprev(equalto(Char(b)), a, i) -@deprecate rsearch(a::ByteArray, b::Char, i::Integer = endof(a)) findprev(equalto(UInt8(b)), a, i) +@deprecate rsearch(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = endindex(a)) findprev(equalto(b), a, i) +@deprecate rsearch(a::String, b::Union{Int8,UInt8}, i::Integer = endindex(a)) findprev(equalto(Char(b)), a, i) +@deprecate rsearch(a::ByteArray, b::Char, i::Integer = endindex(a)) findprev(equalto(UInt8(b)), a, i) @deprecate searchindex(s::AbstractString, t::AbstractString) first(findfirst(t, s)) @deprecate searchindex(s::AbstractString, t::AbstractString, i::Integer) first(findnext(t, s, i)) @@ -3889,6 +3889,11 @@ end @deprecate findin(a, b) find(occursin(b), a) +@deprecate endof(a) endindex(a) +function beginindex(a) + depwarn("if appropriate you should implement `beginindex` for type $(typeof(a)), which might just return 1", :beginof) + 1 +end # END 0.7 deprecations # BEGIN 1.0 deprecations diff --git a/base/dict.jl b/base/dict.jl index 3e5534885318a..c4388d9611428 100644 --- a/base/dict.jl +++ b/base/dict.jl @@ -16,7 +16,7 @@ function _truncate_at_width_or_chars(str, width, chars="", truncmark="…") lastidx != 0 && str[lastidx] in chars && (lastidx = prevind(str, lastidx)) truncidx == 0 && (truncidx = lastidx) - if lastidx < endof(str) + if lastidx < endindex(str) return String(SubString(str, 1, truncidx) * truncmark) else return String(str) diff --git a/base/essentials.jl b/base/essentials.jl index fb4608fdaa2a3..ba1e854188552 100644 --- a/base/essentials.jl +++ b/base/essentials.jl @@ -546,7 +546,8 @@ function length(v::SimpleVector) @_gc_preserve_end t return l end -endof(v::SimpleVector) = length(v) +beginindex(v::SimpleVector) = 1 +endindex(v::SimpleVector) = length(v) start(v::SimpleVector) = 1 next(v::SimpleVector,i) = (v[i],i+1) done(v::SimpleVector,i) = (length(v) < i) diff --git a/base/exports.jl b/base/exports.jl index bbc505393a62e..428b9b6721e55 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -619,6 +619,7 @@ export allunique, any!, any, + beginindex, collect, count, delete!, @@ -626,7 +627,7 @@ export eltype, empty!, empty, - endof, + endindex, filter!, filter, foldl, diff --git a/base/gmp.jl b/base/gmp.jl index 37f47cc8932fa..dbad2c208a903 100644 --- a/base/gmp.jl +++ b/base/gmp.jl @@ -238,9 +238,9 @@ hastypemax(::Type{BigInt}) = false function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, endpos::Int, base_::Integer, raise::Bool) # don't make a copy in the common case where we are parsing a whole String - bstr = startpos == start(s) && endpos == endof(s) ? String(s) : String(SubString(s,startpos,endpos)) + bstr = startpos == start(s) && endpos == endindex(s) ? String(s) : String(SubString(s,startpos,endpos)) - sgn, base, i = Base.parseint_preamble(true,Int(base_),bstr,start(bstr),endof(bstr)) + sgn, base, i = Base.parseint_preamble(true,Int(base_),bstr,start(bstr),endindex(bstr)) if !(2 <= base <= 62) raise && throw(ArgumentError("invalid base: base must be 2 ≤ base ≤ 62, got $base")) return nothing diff --git a/base/int.jl b/base/int.jl index fbe352b343ad9..ffa0e885e232e 100644 --- a/base/int.jl +++ b/base/int.jl @@ -539,9 +539,9 @@ end macro big_str(s) if '_' in s # remove _ in s[2:end-1] - bf = IOBuffer(endof(s)) + bf = IOBuffer(endindex(s)) print(bf, s[1]) - for c in SubString(s, 2, endof(s)-1) + for c in SubString(s, 2, endindex(s)-1) c != '_' && print(bf, c) end print(bf, s[end]) diff --git a/base/io.jl b/base/io.jl index f6882570b7031..8ed2220a8f4df 100644 --- a/base/io.jl +++ b/base/io.jl @@ -648,14 +648,14 @@ function readuntil(s::IO, delim::T) where T return out end -# requires that indices for target are small ordered integers bounded by start and endof +# requires that indices for target are small ordered integers bounded by start and endindex function readuntil_indexable(io::IO, target#=::Indexable{T}=#, out) T = eltype(target) first = start(target) if done(target, first) return end - len = endof(target) + len = endindex(target) local cache # will be lazy initialized when needed second = next(target, first)[2] max_pos = second diff --git a/base/markdown/parse/parse.jl b/base/markdown/parse/parse.jl index b9a2f9c1f36c2..22d1b40213789 100644 --- a/base/markdown/parse/parse.jl +++ b/base/markdown/parse/parse.jl @@ -23,7 +23,8 @@ config(md::MD) = md.meta[:config]::Config Base.push!(md::MD, x) = push!(md.content, x) Base.getindex(md::MD, args...) = md.content[args...] Base.setindex!(md::MD, args...) = setindex!(md.content, args...) -Base.endof(md::MD) = endof(md.content) +Base.endindex(md::MD) = endindex(md.content) +Base.beginindex(md::MD) = beginindex(md.content) Base.length(md::MD) = length(md.content) Base.isempty(md::MD) = isempty(md.content) diff --git a/base/namedtuple.jl b/base/namedtuple.jl index 6606456a43462..540dea575ed96 100644 --- a/base/namedtuple.jl +++ b/base/namedtuple.jl @@ -48,7 +48,8 @@ length(t::NamedTuple) = nfields(t) start(t::NamedTuple) = 1 done(t::NamedTuple, iter) = iter > nfields(t) next(t::NamedTuple, iter) = (getfield(t, iter), iter + 1) -endof(t::NamedTuple) = nfields(t) +beginindex(t::NamedTuple) = 1 +endindex(t::NamedTuple) = nfields(t) getindex(t::NamedTuple, i::Int) = getfield(t, i) getindex(t::NamedTuple, i::Symbol) = getfield(t, i) indexed_next(t::NamedTuple, i::Int, state) = (getfield(t, i), i+1) diff --git a/base/number.jl b/base/number.jl index d6c9bd4ca5804..faa516e96b991 100644 --- a/base/number.jl +++ b/base/number.jl @@ -52,7 +52,8 @@ eltype(::Type{T}) where {T<:Number} = T ndims(x::Number) = 0 ndims(::Type{<:Number}) = 0 length(x::Number) = 1 -endof(x::Number) = 1 +beginindex(x::Number) = 1 +endindex(x::Number) = 1 IteratorSize(::Type{<:Number}) = HasShape() keys(::Number) = OneTo(1) diff --git a/base/pair.jl b/base/pair.jl index b55c3e78edb75..7930989b978ad 100644 --- a/base/pair.jl +++ b/base/pair.jl @@ -52,7 +52,8 @@ getindex(p::Pair,i::Int) = getfield(p,i) getindex(p::Pair,i::Real) = getfield(p, convert(Int, i)) reverse(p::Pair{A,B}) where {A,B} = Pair{B,A}(p.second, p.first) -endof(p::Pair) = 2 +beginindex(p::Pair) = 1 +endindex(p::Pair) = 2 length(p::Pair) = 2 first(p::Pair) = p.first last(p::Pair) = p.second diff --git a/base/parse.jl b/base/parse.jl index e0da3ea303058..37e88235d83a9 100644 --- a/base/parse.jl +++ b/base/parse.jl @@ -208,16 +208,16 @@ Like [`parse`](@ref), but returns either a value of the requested type, or [`nothing`](@ref) if the string does not contain a valid number. """ tryparse(::Type{T}, s::AbstractString, base::Integer) where {T<:Integer} = - tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), false) + tryparse_internal(T, s, start(s), endindex(s), check_valid_base(base), false) tryparse(::Type{T}, s::AbstractString) where {T<:Integer} = - tryparse_internal(T, s, start(s), endof(s), 0, false) + tryparse_internal(T, s, start(s), endindex(s), 0, false) function parse(::Type{T}, s::AbstractString, base::Integer) where T<:Integer - tryparse_internal(T, s, start(s), endof(s), check_valid_base(base), true) + tryparse_internal(T, s, start(s), endindex(s), check_valid_base(base), true) end function parse(::Type{T}, s::AbstractString) where T<:Integer - tryparse_internal(T, s, start(s), endof(s), 0, true) # Zero means, "figure it out" + tryparse_internal(T, s, start(s), endindex(s), 0, true) # Zero means, "figure it out" end ## string to float functions ## @@ -331,7 +331,7 @@ tryparse_internal(T::Type{<:Complex}, s::AbstractString, i::Int, e::Int, raise:: # fallback methods for tryparse_internal tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int) where T<:Real = - startpos == start(s) && endpos == endof(s) ? tryparse(T, s) : tryparse(T, SubString(s, startpos, endpos)) + startpos == start(s) && endpos == endindex(s) ? tryparse(T, s) : tryparse(T, SubString(s, startpos, endpos)) function tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, raise::Bool) where T<:Real result = tryparse_internal(T, s, startpos, endpos) if raise && result === nothing @@ -343,4 +343,4 @@ tryparse_internal(::Type{T}, s::AbstractString, startpos::Int, endpos::Int, rais tryparse_internal(T, s, startpos, endpos, 10, raise) parse(::Type{T}, s::AbstractString) where T<:Union{Real,Complex} = - tryparse_internal(T, s, start(s), endof(s), true) + tryparse_internal(T, s, start(s), endindex(s), true) diff --git a/base/precompile.jl b/base/precompile.jl index b19f6e7f1625d..fd73543bd0894 100644 --- a/base/precompile.jl +++ b/base/precompile.jl @@ -774,11 +774,11 @@ precompile(Tuple{Type{BoundsError}, Array{Expr, 1}, Base.UnitRange{Int64}}) precompile(Tuple{getfield(Base.Cartesian, Symbol("#@ncall")), Int64, Symbol, Symbol}) precompile(Tuple{typeof(Base.getindex), Tuple{Symbol}, Base.UnitRange{Int64}}) precompile(Tuple{getfield(Base.Cartesian, Symbol("#@ncall")), Int64, Symbol, Symbol, Expr}) -precompile(Tuple{typeof(Base.endof), Tuple{Symbol, Expr}}) +precompile(Tuple{typeof(Base.endindex), Tuple{Symbol, Expr}}) precompile(Tuple{typeof(Base.getindex), Tuple{Symbol, Expr}, Base.UnitRange{Int64}}) precompile(Tuple{getfield(Base.Cartesian, Symbol("#@nloops")), Int64, Symbol, Expr, Expr}) -precompile(Tuple{typeof(Base.endof), Tuple{Expr}}) -precompile(Tuple{typeof(Base.endof), Tuple{Symbol, Symbol, Symbol}}) +precompile(Tuple{typeof(Base.endindex), Tuple{Expr}}) +precompile(Tuple{typeof(Base.endindex), Tuple{Symbol, Symbol, Symbol}}) precompile(Tuple{typeof(Base.getindex), Tuple{Symbol, Symbol, Symbol}, Base.UnitRange{Int64}}) precompile(Tuple{Type{Expr}, Symbol, Symbol, Symbol, Symbol, Symbol, Symbol}) precompile(Tuple{typeof(Base.join), Base.GenericIOBuffer{Array{UInt8, 1}}, Tuple{String, String}, Char}) @@ -991,7 +991,7 @@ precompile(Tuple{typeof(Base.Markdown.terminline), Base.GenericIOBuffer{Array{UI precompile(Tuple{typeof(Base._search), Base.SubString{String}, String, Int64}) precompile(Tuple{typeof(Base._split), Base.SubString{String}, String, Int64, Bool, Array{Base.SubString{String}, 1}}) precompile(Tuple{getfield(Base.Markdown, Symbol("#kw##wrapped_lines")), Array{Any, 1}, typeof(Base.Markdown.wrapped_lines), Base.SubString{String}}) -precompile(Tuple{typeof(Base.endof), Array{AbstractString, 1}}) +precompile(Tuple{typeof(Base.endindex), Array{AbstractString, 1}}) precompile(Tuple{typeof(Base.getindex), Array{AbstractString, 1}, Base.UnitRange{Int64}}) precompile(Tuple{typeof(Base.throw_boundserror), Array{AbstractString, 1}, Tuple{Base.UnitRange{Int64}}}) precompile(Tuple{typeof(Base.unsafe_copyto!), Array{AbstractString, 1}, Int64, Array{AbstractString, 1}, Int64, Int64}) diff --git a/base/printf.jl b/base/printf.jl index 19c3bf56faa4f..b889f17ea2136 100644 --- a/base/printf.jl +++ b/base/printf.jl @@ -54,7 +54,7 @@ function parse(s::AbstractString) j1 = j j = k end - i > endof(s) || push!(list, s[i:end]) + i > endindex(s) || push!(list, s[i:end]) # coalesce adjacent strings i = 1 while i < length(list) diff --git a/base/process.jl b/base/process.jl index aec5045839af4..0eb38e0529cf0 100644 --- a/base/process.jl +++ b/base/process.jl @@ -829,7 +829,7 @@ wait(x::ProcessChain) = for p in x.processes; wait(p); end show(io::IO, p::Process) = print(io, "Process(", p.cmd, ", ", process_status(p), ")") # allow the elements of the Cmd to be accessed as an array or iterator -for f in (:length, :endof, :start, :keys, :eltype, :first, :last) +for f in (:length, :beginindex, :endindex, :start, :keys, :eltype, :first, :last) @eval $f(cmd::Cmd) = $f(cmd.exec) end for f in (:next, :done, :getindex) diff --git a/base/random/generation.jl b/base/random/generation.jl index 0d36a6a7c9f5b..194898bfe9955 100644 --- a/base/random/generation.jl +++ b/base/random/generation.jl @@ -416,12 +416,12 @@ Sampler(rng::AbstractRNG, str::AbstractString, n::Val{Inf}) = Sampler(rng, colle # when generating only one char from a string, the specialized method below # is usually more efficient Sampler(rng::AbstractRNG, str::AbstractString, ::Val{1}) = - SamplerSimple(str, Sampler(rng, 1:_endof(str), Val(Inf))) + SamplerSimple(str, Sampler(rng, 1:_endindex(str), Val(Inf))) isvalid_unsafe(s::String, i) = !Base.is_valid_continuation(Base.@gc_preserve s unsafe_load(pointer(s), i)) isvalid_unsafe(s::AbstractString, i) = isvalid(s, i) -_endof(s::String) = sizeof(s) -_endof(s::AbstractString) = endof(s) +_endindex(s::String) = sizeof(s) +_endindex(s::AbstractString) = endindex(s) function rand(rng::AbstractRNG, sp::SamplerSimple{<:AbstractString,<:Sampler})::Char str = sp[] diff --git a/base/reduce.jl b/base/reduce.jl index 72000e3e2aae3..c11bddc528059 100644 --- a/base/reduce.jl +++ b/base/reduce.jl @@ -126,7 +126,7 @@ end Like [`mapreduce`](@ref), but with guaranteed right associativity, as in [`foldr`](@ref). `v0` will be used exactly once. """ -mapfoldr(f, op, v0, itr) = mapfoldr_impl(f, op, v0, itr, endof(itr)) +mapfoldr(f, op, v0, itr) = mapfoldr_impl(f, op, v0, itr, endindex(itr)) """ mapfoldr(f, op, itr) @@ -137,7 +137,7 @@ Specifically, `mapfoldr(f, op, itr)` produces the same result as In general, this cannot be used with empty collections (see [`reduce(op, itr)`](@ref)). """ function mapfoldr(f, op, itr) - i = endof(itr) + i = endindex(itr) if isempty(itr) return Base.mapreduce_empty_iter(f, op, itr, IteratorEltype(itr)) end diff --git a/base/regex.jl b/base/regex.jl index 0cc75f5e21de1..3a26d13fc8bb1 100644 --- a/base/regex.jl +++ b/base/regex.jl @@ -267,7 +267,7 @@ matchall(re::Regex, str::SubString, overlap::Bool=false) = # TODO: return only start index and update deprecation function findnext(re::Regex, str::Union{String,SubString}, idx::Integer) - if idx > nextind(str,endof(str)) + if idx > nextind(str,endindex(str)) throw(BoundsError()) end opts = re.match_options @@ -315,7 +315,7 @@ function _replace(io, repl_s::SubstitutionString, str, r, re) RBRACKET = '>' repl = repl_s.string i = start(repl) - e = endof(repl) + e = endindex(repl) while i <= e if repl[i] == SUB_CHAR next_i = nextind(repl, i) @@ -393,7 +393,7 @@ function next(itr::RegexMatchIterator, prev_match) offset = prev_match.offset end else - offset = prev_match.offset + endof(prev_match.match) + offset = prev_match.offset + endindex(prev_match.match) end opts_nonempty = UInt32(PCRE.ANCHORED | PCRE.NOTEMPTY_ATSTART) diff --git a/base/repl/LineEdit.jl b/base/repl/LineEdit.jl index 7f92d6d047b4d..a5f64ea0cfc07 100644 --- a/base/repl/LineEdit.jl +++ b/base/repl/LineEdit.jl @@ -261,10 +261,10 @@ function common_prefix(completions) cc, nexti = next(c1, i) while true for c in completions - (i > endof(c) || c[i] != cc) && return ret + (i > endindex(c) || c[i] != cc) && return ret end ret = string(ret, cc) - i >= endof(c1) && return ret + i >= endindex(c1) && return ret i = nexti cc, nexti = next(c1, i) end @@ -729,7 +729,7 @@ _notspace(c) = c != _space beginofline(buf, pos=position(buf)) = findprev(equalto(_newline), buf.data, pos) -function endofline(buf, pos=position(buf)) +function endindexline(buf, pos=position(buf)) eol = findnext(equalto(_newline), buf.data[pos+1:buf.size], 1) eol == 0 ? buf.size : pos + eol - 1 end @@ -870,7 +870,7 @@ function push_kill!(s::MIState, killed::String, concat = s.key_repeats > 0; rev= push!(s.kill_ring, killed) length(s.kill_ring) > options(s).kill_ring_max && popfirst!(s.kill_ring) end - s.kill_idx = endof(s.kill_ring) + s.kill_idx = endindex(s.kill_ring) true end @@ -884,7 +884,7 @@ function edit_kill_line(s::MIState, backwards::Bool=false) else set_action!(s, :edit_kill_line_forwards) pos = position(buf) - endpos = endofline(buf) + endpos = endindexline(buf) endpos == pos && buf.size > pos && (endpos += 1) end push_undo(s) @@ -978,7 +978,7 @@ function edit_transpose_lines_up!(buf::IOBuffer, reg::Region) line1 = edit_splice!(buf, b1 => b2) # delete whole previous line line1 = '\n'*line1[1:end-1] # don't include the final '\n' pos = position(buf) # save pos in case it's at the end of line - b = endofline(buf, last(reg) - b2 + b1) # b2-b1 is the size of the removed line1 + b = endindexline(buf, last(reg) - b2 + b1) # b2-b1 is the size of the removed line1 edit_splice!(buf, b => b, line1) seek(buf, pos) true @@ -986,9 +986,9 @@ end # swap all lines intersecting the region with line below function edit_transpose_lines_down!(buf::IOBuffer, reg::Region) - e1 = endofline(buf, last(reg)) + e1 = endindexline(buf, last(reg)) e1 == buf.size && return false - e2 = endofline(buf, e1+1) + e2 = endindexline(buf, e1+1) line2 = edit_splice!(buf, e1 => e2) # delete whole next line line2 = line2[2:end]*'\n' # don't include leading '\n' b = beginofline(buf, first(reg)) @@ -1096,7 +1096,7 @@ function get_lines_in_region(s)::Vector{Int} b, e = region(buf) bol = Int[beginofline(buf, b)] # begin of lines while true - b = endofline(buf, b) + b = endindexline(buf, b) b >= e && break # b < e ==> b+1 <= e <= buf.size push!(bol, b += 1) diff --git a/base/repl/REPL.jl b/base/repl/REPL.jl index 3858fb985902b..9deabae88a27c 100644 --- a/base/repl/REPL.jl +++ b/base/repl/REPL.jl @@ -333,7 +333,7 @@ beforecursor(buf::IOBuffer) = String(buf.data[1:buf.ptr-1]) function complete_line(c::REPLCompletionProvider, s) partial = beforecursor(s.input_buffer) full = LineEdit.input_string(s) - ret, range, should_complete = completions(full, endof(partial)) + ret, range, should_complete = completions(full, endindex(partial)) return ret, partial[range], should_complete end @@ -341,14 +341,14 @@ function complete_line(c::ShellCompletionProvider, s) # First parse everything up to the current position partial = beforecursor(s.input_buffer) full = LineEdit.input_string(s) - ret, range, should_complete = shell_completions(full, endof(partial)) + ret, range, should_complete = shell_completions(full, endindex(partial)) return ret, partial[range], should_complete end function complete_line(c::LatexCompletions, s) partial = beforecursor(LineEdit.buffer(s)) full = LineEdit.input_string(s) - ret, range, should_complete = bslash_completions(full, endof(partial))[2] + ret, range, should_complete = bslash_completions(full, endindex(partial))[2] return ret, partial[range], should_complete end @@ -613,7 +613,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo # into the search data to index into the response string b = a + sizeof(searchdata) b = b ≤ ncodeunits(response_str) ? prevind(response_str, b) : b-1 - b = min(endof(response_str), b) # ensure that b is valid + b = min(endindex(response_str), b) # ensure that b is valid !skip_current && searchdata == response_str[a:b] && return true @@ -624,7 +624,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo # Start searching # First the current response buffer - if 1 <= searchstart <= endof(response_str) + if 1 <= searchstart <= endindex(response_str) match = searchfunc2(searchdata, response_str, searchstart) if match != 0:-1 seek(response_buffer, first(match) - 1) diff --git a/base/repl/REPLCompletions.jl b/base/repl/REPLCompletions.jl index 4c80882b94a2e..78d3fe627263a 100644 --- a/base/repl/REPLCompletions.jl +++ b/base/repl/REPLCompletions.jl @@ -191,10 +191,10 @@ function complete_path(path::AbstractString, pos; use_envpath=false) end matchList = String[replace(s, r"\s" => "\\ ") for s in matches] - startpos = pos - endof(prefix) + 1 - length(matchall(r" ", prefix)) - # The pos - endof(prefix) + 1 is correct due to `endof(prefix)-endof(prefix)==0`, + startpos = pos - endindex(prefix) + 1 - length(matchall(r" ", prefix)) + # The pos - endindex(prefix) + 1 is correct due to `endindex(prefix)-endindex(prefix)==0`, # hence we need to add one to get the first index. This is also correct when considering - # pos, because pos is the `endof` a larger string which `endswith(path)==true`. + # pos, because pos is the `endindex` a larger string which `endswith(path)==true`. return matchList, startpos:pos, !isempty(matchList) end @@ -259,7 +259,7 @@ function find_start_brace(s::AbstractString; c_start='(', c_end=')') braces != 1 && return 0:-1, -1 method_name_end = reverseind(s, i) startind = nextind(s, findprev(occursin(non_identifier_chars), s, method_name_end)) - return (startind:endof(s), method_name_end) + return (startind:endindex(s), method_name_end) end # Returns the value in a expression if sym is defined in current namespace fn. @@ -637,7 +637,7 @@ function shell_completions(string, pos) elseif isexpr(arg, :incomplete) || isexpr(arg, :error) r = first(last_parse):prevind(last_parse, last(last_parse)) partial = scs[r] - ret, range = completions(partial, endof(partial)) + ret, range = completions(partial, endindex(partial)) range = range .+ (first(r) - 1) return ret, range, true end diff --git a/base/strings/basic.jl b/base/strings/basic.jl index 0fba9536b194e..4af06bc58d187 100644 --- a/base/strings/basic.jl +++ b/base/strings/basic.jl @@ -51,7 +51,7 @@ are valid – they may not be the start of a character, but they will return a code unit value when calling `codeunit(s,i)`. See also: [`codeunit`](@ref), [`checkbounds`](@ref), [`sizeof`](@ref), -[`length`](@ref), [`endof`](@ref) +[`length`](@ref), [`endindex`](@ref) """ ncodeunits(s::AbstractString) @@ -142,7 +142,8 @@ start(s::AbstractString) = 1 done(s::AbstractString, i::Integer) = i > ncodeunits(s) eltype(::Type{<:AbstractString}) = Char sizeof(s::AbstractString) = ncodeunits(s) * sizeof(codeunit(s)) -endof(s::AbstractString) = thisind(s, ncodeunits(s)) +beginindex(s::AbstractString) = 1 +endindex(s::AbstractString) = thisind(s, ncodeunits(s)) function getindex(s::AbstractString, i::Integer) @boundscheck checkbounds(s, i) @@ -324,7 +325,7 @@ indices in the string `s`. In addition to in-bounds values, `i` may take the out-of-bounds value `ncodeunits(s) + 1` and `j` may take the out-of-bounds value `0`. -See also: [`isvalid`](@ref), [`ncodeunits`](@ref), [`endof`](@ref), +See also: [`isvalid`](@ref), [`ncodeunits`](@ref), [`endindex`](@ref), [`thisind`](@ref), [`nextind`](@ref), [`prevind`](@ref) # Examples @@ -450,7 +451,7 @@ julia> nextind(str, 1) julia> nextind(str, 1, 2) 5 -julia> endof(str) +julia> endindex(str) 9 julia> nextind(str, 9) @@ -512,7 +513,7 @@ isascii(s::AbstractString) = all(isascii, s) ## string map, filter, has ## function map(f, s::AbstractString) - out = IOBuffer(StringVector(endof(s)), true, true) + out = IOBuffer(StringVector(endindex(s)), true, true) truncate(out, 0) for c in s c′ = f(c) @@ -525,7 +526,7 @@ function map(f, s::AbstractString) end function filter(f, s::AbstractString) - out = IOBuffer(StringVector(endof(s)), true, true) + out = IOBuffer(StringVector(endindex(s)), true, true) truncate(out, 0) for c in s f(c) && write(out, c) @@ -622,10 +623,10 @@ julia> "Test "^3 (^)(s::Union{AbstractString,Char}, r::Integer) = repeat(s, r) # reverse-order iteration for strings and indices thereof -start(r::Iterators.Reverse{<:AbstractString}) = endof(r.itr) +start(r::Iterators.Reverse{<:AbstractString}) = endindex(r.itr) done(r::Iterators.Reverse{<:AbstractString}, i) = i < start(r.itr) next(r::Iterators.Reverse{<:AbstractString}, i) = (r.itr[i], prevind(r.itr, i)) -start(r::Iterators.Reverse{<:EachStringIndex}) = endof(r.itr.s) +start(r::Iterators.Reverse{<:EachStringIndex}) = endindex(r.itr.s) done(r::Iterators.Reverse{<:EachStringIndex}, i) = i < start(r.itr.s) next(r::Iterators.Reverse{<:EachStringIndex}, i) = (i, prevind(r.itr.s, i)) diff --git a/base/strings/io.jl b/base/strings/io.jl index 1e4c46124dd83..d30b6f7aa62f1 100644 --- a/base/strings/io.jl +++ b/base/strings/io.jl @@ -94,7 +94,7 @@ function sprint(f::Function, args...; context=nothing, sizehint::Integer=0) end tostr_sizehint(x) = 0 -tostr_sizehint(x::AbstractString) = endof(x) +tostr_sizehint(x::AbstractString) = endindex(x) tostr_sizehint(x::Float64) = 20 tostr_sizehint(x::Float32) = 12 @@ -257,8 +257,8 @@ General escaping of traditional C and Unicode escape sequences. Any characters in `esc` are also escaped (with a backslash). The reverse is [`unescape_string`](@ref). """ -escape_string(s::AbstractString, esc::AbstractString) = sprint(escape_string, s, esc, sizehint=endof(s)) -escape_string(s::AbstractString) = sprint(escape_string, s, "\"", sizehint=endof(s)) +escape_string(s::AbstractString, esc::AbstractString) = sprint(escape_string, s, esc, sizehint=endindex(s)) +escape_string(s::AbstractString) = sprint(escape_string, s, "\"", sizehint=endindex(s)) """ escape_string(io, str::AbstractString[, esc::AbstractString]) -> Nothing @@ -311,7 +311,7 @@ end General unescaping of traditional C and Unicode escape sequences. Reverse of [`escape_string`](@ref). """ -unescape_string(s::AbstractString) = sprint(unescape_string, s, sizehint=endof(s)) +unescape_string(s::AbstractString) = sprint(unescape_string, s, sizehint=endindex(s)) """ unescape_string(io, str::AbstractString) -> Nothing @@ -442,7 +442,7 @@ Returns: function unindent(str::AbstractString, indent::Int; tabwidth=8) indent == 0 && return str pos = start(str) - endpos = endof(str) + endpos = endindex(str) # Note: this loses the type of the original string buf = IOBuffer(StringVector(endpos), true, true) truncate(buf,0) diff --git a/base/strings/search.jl b/base/strings/search.jl index 8002e9fdd59e1..f141fccec80e6 100644 --- a/base/strings/search.jl +++ b/base/strings/search.jl @@ -118,7 +118,7 @@ function _searchindex(s::Union{AbstractString,ByteArray}, t::Union{AbstractString,Char,Int8,UInt8}, i::Integer) if isempty(t) - return 1 <= i <= nextind(s,endof(s)) ? i : + return 1 <= i <= nextind(s,endindex(s)) ? i : throw(BoundsError(s, i)) end t1, j2 = next(t,start(t)) @@ -158,7 +158,7 @@ _nthbyte(a::Union{AbstractVector{UInt8},AbstractVector{Int8}}, i) = a[i] function _searchindex(s::String, t::String, i::Integer) # Check for fast case of a single byte - endof(t) == 1 && return findnext(equalto(t[1]), s, i) + endindex(t) == 1 && return findnext(equalto(t[1]), s, i) _searchindex(unsafe_wrap(Vector{UInt8},s), unsafe_wrap(Vector{UInt8},t), i) end @@ -230,7 +230,7 @@ function _search(s::Union{AbstractString,ByteArray}, if isempty(t) idx:idx-1 else - idx:(idx > 0 ? idx + endof(t) - 1 : -1) + idx:(idx > 0 ? idx + endindex(t) - 1 : -1) end end @@ -267,7 +267,7 @@ findnext(t::AbstractString, s::AbstractString, i::Integer) = _search(s, t, i) findlast(pattern::Regex, string::String) Find the last occurrence of `pattern` in `string`. Equivalent to -[`findlast(pattern, string, endof(s))`](@ref). +[`findlast(pattern, string, endindex(s))`](@ref). # Examples ```jldoctest @@ -279,7 +279,7 @@ julia> findfirst("Julia", "JuliaLang") ``` """ findlast(pattern::AbstractString, string::AbstractString) = - findprev(pattern, string, endof(string)) + findprev(pattern, string, endindex(string)) # AbstractString implementation of the generic findprev interface function findprev(testf::Function, s::AbstractString, i::Integer) @@ -301,12 +301,12 @@ function _rsearchindex(s::AbstractString, t::Union{AbstractString,Char,Int8,UInt8}, i::Integer) if isempty(t) - return 1 <= i <= nextind(s, endof(s)) ? i : + return 1 <= i <= nextind(s, endindex(s)) ? i : throw(BoundsError(s, i)) end t = t isa AbstractString ? reverse(t) : t rs = reverse(s) - l = endof(s) + l = endindex(s) t1, j2 = next(t, start(t)) while true i = findprev(equalto(t1), s, i) @@ -333,9 +333,9 @@ end function _rsearchindex(s::String, t::String, i::Integer) # Check for fast case of a single byte - if endof(t) == 1 + if endindex(t) == 1 return findprev(equalto(t[1]), s, i) - elseif endof(t) != 0 + elseif endindex(t) != 0 j = i ≤ ncodeunits(s) ? nextind(s, i)-1 : i return _rsearchindex(unsafe_wrap(Vector{UInt8}, s), unsafe_wrap(Vector{UInt8}, t), j) elseif i > sizeof(s) @@ -415,7 +415,7 @@ function _rsearch(s::Union{AbstractString,ByteArray}, if isempty(t) idx:idx-1 else - idx:(idx > 0 ? idx + endof(t) - 1 : -1) + idx:(idx > 0 ? idx + endindex(t) - 1 : -1) end end diff --git a/base/strings/substring.jl b/base/strings/substring.jl index f4cf3c9311537..9b156c49a6272 100644 --- a/base/strings/substring.jl +++ b/base/strings/substring.jl @@ -1,7 +1,7 @@ # This file is a part of Julia. License is MIT: https://julialang.org/license """ - SubString(s::AbstractString, i::Integer, j::Integer=endof(s)) + SubString(s::AbstractString, i::Integer, j::Integer=endindex(s)) SubString(s::AbstractString, r::UnitRange{<:Integer}) Like [`getindex`](@ref), but returns a view into the parent string `s` @@ -36,7 +36,7 @@ struct SubString{T<:AbstractString} <: AbstractString end SubString(s::T, i::Int, j::Int) where {T<:AbstractString} = SubString{T}(s, i, j) -SubString(s::AbstractString, i::Integer, j::Integer=endof(s)) = SubString(s, Int(i), Int(j)) +SubString(s::AbstractString, i::Integer, j::Integer=endindex(s)) = SubString(s, Int(i), Int(j)) SubString(s::AbstractString, r::UnitRange{<:Integer}) = SubString(s, first(r), last(r)) function SubString(s::SubString, i::Int, j::Int) @@ -44,8 +44,8 @@ function SubString(s::SubString, i::Int, j::Int) SubString(s.string, s.offset+i, s.offset+j) end -SubString(s::AbstractString) = SubString(s, 1, endof(s)) -SubString{T}(s::T) where {T<:AbstractString} = SubString{T}(s, 1, endof(s)) +SubString(s::AbstractString) = SubString(s, 1, endindex(s)) +SubString{T}(s::T) where {T<:AbstractString} = SubString{T}(s, 1, endindex(s)) convert(::Type{SubString{S}}, s::AbstractString) where {S<:AbstractString} = SubString(convert(S, s)) @@ -148,7 +148,7 @@ julia> join(reverse(collect(graphemes("ax̂e")))) # reverses graphemes """ function reverse(s::Union{String,SubString{String}})::String sprint() do io - i, j = start(s), endof(s) + i, j = start(s), endindex(s) while i ≤ j c, j = s[j], prevind(s, j) write(io, c) diff --git a/base/strings/util.jl b/base/strings/util.jl index 80788e9b07e13..984b497454291 100644 --- a/base/strings/util.jl +++ b/base/strings/util.jl @@ -45,8 +45,8 @@ true ``` """ function endswith(a::AbstractString, b::AbstractString) - i = endof(a) - j = endof(b) + i = endindex(a) + j = endindex(b) a1 = start(a) b1 = start(b) while a1 <= i && b1 <= j @@ -92,9 +92,9 @@ julia> chop(a, 5, 5) "" ``` """ -chop(s::AbstractString) = SubString(s, start(s), prevind(s, endof(s))) +chop(s::AbstractString) = SubString(s, start(s), prevind(s, endindex(s))) chop(s::AbstractString, head::Integer, tail::Integer) = - SubString(s, nextind(s, start(s), head), prevind(s, endof(s), tail)) + SubString(s, nextind(s, start(s), head), prevind(s, endindex(s), tail)) """ chomp(s::AbstractString) @@ -108,14 +108,14 @@ julia> chomp("Hello\\n") ``` """ function chomp(s::AbstractString) - i = endof(s) + i = endindex(s) (i < 1 || s[i] != '\n') && (return SubString(s, 1, i)) j = prevind(s,i) (j < 1 || s[j] != '\r') && (return SubString(s, 1, j)) return SubString(s, 1, prevind(s,j)) end function chomp(s::String) - i = endof(s) + i = endindex(s) if i < 1 || codeunit(s,i) != 0x0a SubString(s, 1, i) elseif i < 2 || codeunit(s,i-1) != 0x0d @@ -146,7 +146,7 @@ julia> lstrip(a) ``` """ function lstrip(s::AbstractString, chars::Chars=_default_delims) - e = endof(s) + e = endindex(s) i = start(s) while !done(s,i) c, j = next(s,i) @@ -178,7 +178,7 @@ julia> rstrip(a) """ function rstrip(s::AbstractString, chars::Chars=_default_delims) a = start(s) - i = endof(s) + i = endindex(s) while a ≤ i c = s[i] j = prevind(s, i) @@ -298,7 +298,7 @@ split(str::T, splitter::Char; function _split(str::AbstractString, splitter, limit::Integer, keep_empty::Bool, strs::Array) i = start(str) - n = endof(str) + n = endindex(str) r = findfirst(splitter,str) if r != 0:-1 j, k = first(r), nextind(str,last(r)) @@ -365,7 +365,7 @@ rsplit(str::T, splitter::Char; function _rsplit(str::AbstractString, splitter, limit::Integer, keep_empty::Bool, strs::Array) i = start(str) - n = endof(str) + n = endindex(str) r = findlast(splitter, str) j = first(r)-1 k = last(r) @@ -398,7 +398,7 @@ function replace(str::String, pat_repl::Pair; count::Integer=typemax(Int)) count == 0 && return str count < 0 && throw(DomainError(count, "`count` must be non-negative.")) n = 1 - e = endof(str) + e = endindex(str) i = a = start(str) r = findnext(pattern,str,i) j, k = first(r), last(r) @@ -501,7 +501,7 @@ hex2bytes(s::Union{String,AbstractVector{UInt8}}) = hex2bytes!(Vector{UInt8}(uni _firstbyteidx(s::String) = 1 _firstbyteidx(s::AbstractVector{UInt8}) = first(eachindex(s)) _lastbyteidx(s::String) = sizeof(s) -_lastbyteidx(s::AbstractVector{UInt8}) = endof(s) +_lastbyteidx(s::AbstractVector{UInt8}) = endindex(s) """ hex2bytes!(d::AbstractVector{UInt8}, s::Union{String,AbstractVector{UInt8}}) diff --git a/base/subarray.jl b/base/subarray.jl index d1a2b9bd94b1b..53047833a4972 100644 --- a/base/subarray.jl +++ b/base/subarray.jl @@ -375,14 +375,14 @@ end replace_ref_end!(ex) Recursively replace occurrences of the symbol :end in a "ref" expression (i.e. A[...]) `ex` -with the appropriate function calls (`endof` or `size`). Replacement uses +with the appropriate function calls (`endindex` or `size`). Replacement uses the closest enclosing ref, so A[B[end]] should transform to - A[B[endof(B)]] + A[B[endindex(B)]] """ replace_ref_end!(ex) = replace_ref_end_!(ex, nothing)[1] @@ -402,11 +402,11 @@ function replace_ref_end_!(ex, withex) if nargs == 0 return ex, used_withex elseif nargs == 1 - # replace with endof(S) - ex.args[2], used_S = replace_ref_end_!(ex.args[2],:($endof($S))) + # replace with endindex(S) + ex.args[2], used_S = replace_ref_end_!(ex.args[2],:($endindex($S))) else n = 1 - J = endof(ex.args) + J = endindex(ex.args) for j = 2:J exj, used = replace_ref_end_!(ex.args[j],:($size($S,$n))) used_S |= used @@ -499,7 +499,7 @@ end # _views implements the transformation for the @views macro. # @views calls esc(_views(...)) to work around #20241, # so any function calls we insert (to maybeview, or to -# size and endof in replace_ref_end!) must be interpolated +# size and endindex in replace_ref_end!) must be interpolated # as values rather than as symbols to ensure that they are called # from Base rather than from the caller's scope. _views(x) = x diff --git a/base/tuple.jl b/base/tuple.jl index 2fa6d80d17ff7..a2382bc554c55 100644 --- a/base/tuple.jl +++ b/base/tuple.jl @@ -16,7 +16,8 @@ NTuple ## indexing ## length(t::Tuple) = nfields(t) -endof(t::Tuple) = length(t) +beginindex(t::Tuple) = 1 +endindex(t::Tuple) = length(t) size(t::Tuple, d) = (d == 1) ? length(t) : throw(ArgumentError("invalid tuple dimension $d")) @eval getindex(t::Tuple, i::Int) = getfield(t, i, $(Expr(:boundscheck))) @eval getindex(t::Tuple, i::Real) = getfield(t, convert(Int, i), $(Expr(:boundscheck))) diff --git a/doc/src/manual/functions.md b/doc/src/manual/functions.md index f6ffc69821f35..e481c1668aefc 100644 --- a/doc/src/manual/functions.md +++ b/doc/src/manual/functions.md @@ -692,7 +692,8 @@ the results (see [Pre-allocating outputs](@ref)). A convenient syntax for this i is equivalent to `broadcast!(identity, X, ...)` except that, as above, the `broadcast!` loop is fused with any nested "dot" calls. For example, `X .= sin.(Y)` is equivalent to `broadcast!(sin, X, Y)`, overwriting `X` with `sin.(Y)` in-place. If the left-hand side is an array-indexing expression, -e.g. `X[2:end] .= sin.(Y)`, then it translates to `broadcast!` on a `view`, e.g. `broadcast!(sin, view(X, 2:endof(X)), Y)`, +e.g. `X[begin+1:end] .= sin.(Y)`, then it translates to `broadcast!` on a `view`, e.g. +`broadcast!(sin, view(X, beginindex(X)+1:endindex(X)), Y)`, so that the left-hand side is updated in-place. Since adding dots to many operations and function calls in an expression diff --git a/doc/src/manual/interacting-with-julia.md b/doc/src/manual/interacting-with-julia.md index 1f4b067e939ce..6525cf248a83d 100644 --- a/doc/src/manual/interacting-with-julia.md +++ b/doc/src/manual/interacting-with-julia.md @@ -324,7 +324,7 @@ Fields for output from functions can also be completed: ```julia-repl julia> split("","")[1].[TAB] -endof offset string +endindex offset string ``` The completion of fields for output from functions uses type inference, and it can only suggest diff --git a/doc/src/manual/interfaces.md b/doc/src/manual/interfaces.md index 4cf5e6768d310..1b04590b75a04 100644 --- a/doc/src/manual/interfaces.md +++ b/doc/src/manual/interfaces.md @@ -161,7 +161,8 @@ julia> collect(Iterators.reverse(Squares(10)))' # transposed to save space |:-------------------- |:-------------------------------- | | `getindex(X, i)` | `X[i]`, indexed element access | | `setindex!(X, v, i)` | `X[i] = v`, indexed assignment | -| `endof(X)` | The last index, used in `X[end]` | +| `beginindex(X)` | The first index, used in `X[begin]` | +| `endindex(X)` | The last index, used in `X[end]` | For the `Squares` iterable above, we can easily compute the `i`th element of the sequence by squaring it. We can expose this as an indexing expression `S[i]`. To opt into this behavior, `Squares` @@ -177,11 +178,13 @@ julia> Squares(100)[23] 529 ``` -Additionally, to support the syntax `S[end]`, we must define [`endof`](@ref) to specify the last valid -index: +Additionally, to support the syntax `S[begin]` and `S[end]`, we must define [`beginindex`](@ref) and +[`endindex`](@ref) to specify the first and last valid +index, respectively: ```jldoctest squaretype -julia> Base.endof(S::Squares) = length(S) +julia> Base.beginindex(S::Squares) = 1 +julia> Base.endindex(S::Squares) = length(S) julia> Squares(23)[end] 529 diff --git a/doc/src/manual/strings.md b/doc/src/manual/strings.md index 97991a0681258..38ec082b30906 100644 --- a/doc/src/manual/strings.md +++ b/doc/src/manual/strings.md @@ -168,6 +168,9 @@ julia> """Contains "quote" characters""" If you want to extract a character from a string, you index into it: ```jldoctest helloworldstring +julia> str[begin] +'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase) + julia> str[1] 'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase) @@ -178,12 +181,15 @@ julia> str[end] '\n': ASCII/Unicode U+000a (category Cc: Other, control) ``` -All indexing in Julia is 1-based: the first element of any integer-indexed object is found at +Many Julia objects, including strings, can be indexed with integers. The index of the first +element is returned by [`beginindex(str)`](@ref), and the index of the last element +with [`endindex(str)`](@ref). The keywords `begin` and `end` can be used inside an indexing +operation as shorthand for the first and last index along the given dimension. +Most indexing in Julia is 1-based: the first element of many integer-indexed objects is found at index 1. (As we will see below, this does not necessarily mean that the last element is found at index `n`, where `n` is the length of the string.) -In any indexing expression, the keyword `end` can be used as a shorthand for the last index (computed -by [`endof(str)`](@ref)). You can perform arithmetic and other operations with `end`, just like +You can perform arithmetic and other operations with `end`, just like a normal value: ```jldoctest helloworldstring @@ -197,7 +203,7 @@ julia> str[end÷2] Using an index less than 1 or greater than `end` raises an error: ```jldoctest helloworldstring -julia> str[0] +julia> str[begin-1] ERROR: BoundsError: attempt to access "Hello, world.\n" at index [0] [...] @@ -302,14 +308,14 @@ julia> s[1:4] ``` Because of variable-length encodings, the number of characters in a string (given by [`length(s)`](@ref)) -is not always the same as the last index. If you iterate through the indices 1 through [`endof(s)`](@ref) +is not always the same as the last index. If you iterate through the indices 1 through [`endindex(s)`](@ref) and index into `s`, the sequence of characters returned when errors aren't thrown is the sequence -of characters comprising the string `s`. Thus we have the identity that `length(s) <= endof(s)`, +of characters comprising the string `s`. Thus we have the identity that `length(s) <= endindex(s)`, since each character in a string must have its own index. The following is an inefficient and verbose way to iterate through the characters of `s`: ```jldoctest unicodestring -julia> for i = 1:endof(s) +julia> for i = begindex(s):endindex(s) try println(s[i]) catch @@ -564,13 +570,14 @@ julia> join(["apples", "bananas", "pineapples"], ", ", " and ") Some other useful functions include: - * [`endof(str)`](@ref) gives the maximal (byte) index that can be used to index into `str`. + * [`beginindex(str)`](@ref) gives the minimal (byte) index that can be used to index into `str` (always 1 for strings, not necessarily true for other containers). + * [`endindex(str)`](@ref) gives the maximal (byte) index that can be used to index into `str`. * [`length(str)`](@ref) the number of characters in `str`. * [`length(str, i, j)`](@ref) the number of valid character indices in `str` from `i` to `j`. * [`i = start(str)`](@ref start) gives the first valid index at which a character can be found in `str` (typically 1). * [`c, j = next(str,i)`](@ref next) returns next character at or after the index `i` and the next valid - character index following that. With [`start`](@ref) and [`endof`](@ref), can be used to iterate + character index following that. With [`start`](@ref) and [`endindex`](@ref), can be used to iterate through the characters in `str`. * [`thisind(str, i)`](@ref) given an arbitrary index into a string find the first index of the character into which the index points. * [`nextind(str, i, n=1)`](@ref) find the start of the `n`th character starting after index `i`. diff --git a/doc/src/manual/style-guide.md b/doc/src/manual/style-guide.md index 486aa7fc9a1ac..8f03946935119 100644 --- a/doc/src/manual/style-guide.md +++ b/doc/src/manual/style-guide.md @@ -92,7 +92,7 @@ Instead of: ```julia function double(a::AbstractArray{<:Number}) - for i = 1:endof(a) + for i = beginindex(a):endindex(a) a[i] *= 2 end return a @@ -103,7 +103,7 @@ use: ```julia function double!(a::AbstractArray{<:Number}) - for i = 1:endof(a) + for i = beginindex(a):endindex(a) a[i] *= 2 end return a diff --git a/doc/src/stdlib/collections.md b/doc/src/stdlib/collections.md index 1f6d9d16b6ec5..9f33822e27c63 100644 --- a/doc/src/stdlib/collections.md +++ b/doc/src/stdlib/collections.md @@ -143,7 +143,8 @@ Base.replace! ```@docs Base.getindex Base.setindex! -Base.endof +Base.beginindex +Base.endindex ``` Fully implemented by: diff --git a/doc/src/stdlib/punctuation.md b/doc/src/stdlib/punctuation.md index 13fab22b8d277..fea0cc0c16f4e 100644 --- a/doc/src/stdlib/punctuation.md +++ b/doc/src/stdlib/punctuation.md @@ -38,7 +38,7 @@ Extended documentation for mathematical symbols & functions is [here](@ref math- | `.` | access named fields in objects/modules (calling [`getproperty`](@ref Base.getproperty) or [`setproperty!`](@ref Base.setproperty!)), also prefixes elementwise function calls (calling [`broadcast`](@ref)) | | `a:b` | range a, a+1, a+2, ..., b (calling [`colon`](@ref)) | | `a:s:b` | range a, a+s, a+2s, ..., b (also calling [`colon`](@ref)) | -| `:` | index an entire dimension (1:endof), see [`Colon`](@ref)) | +| `:` | index an entire dimension (beginindex:endindex), see [`Colon`](@ref)) | | `::` | type annotation or [`typeassert`](@ref), depending on context | | `:( )` | quoted expression | | `:a` | symbol a | diff --git a/src/common_symbols2.inc b/src/common_symbols2.inc index e41e64d8d73c3..886322376bf70 100644 --- a/src/common_symbols2.inc +++ b/src/common_symbols2.inc @@ -24,7 +24,7 @@ jl_symbol("push!"), jl_symbol("iter"), jl_symbol(">"), jl_symbol("Base"), -jl_symbol("endof"), +jl_symbol("endindex"), jl_symbol("shl_int"), jl_symbol("Any"), jl_symbol("Enums.jl"), diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm index 28bc5a7bd66cc..82475286a9aac 100644 --- a/src/julia-syntax.scm +++ b/src/julia-syntax.scm @@ -86,35 +86,46 @@ (define (expand-compare-chain e) (car (expand-vector-compare e))) -;; return the appropriate computation for an `end` symbol for indexing +;; return the appropriate computation for a `begin` or `end` symbol for indexing ;; the array `a` in the `n`th index. ;; `tuples` are a list of the splatted arguments that precede index `n` ;; `last` = is this last index? -;; returns a call to endof(a) or size(a,n) +;; returns a call to, e.g., endindex(a) or last(axes(a,n)) (define (end-val a n tuples last) (if (null? tuples) (if (and last (= n 1)) - `(call (top endof) ,a) - `(call (top size) ,a ,n)) + `(call (top endindex) ,a) + `(call (top last) (call (top axes) ,a ,n))) (let ((dimno `(call (top +) ,(- n (length tuples)) ,.(map (lambda (t) `(call (top length) ,t)) tuples)))) - `(call (top size) ,a ,dimno)))) + `(call (top last) (call (top axes) ,a ,dimno))))) -;; replace `end` for the closest ref expression, so doesn't go inside nested refs -(define (replace-end ex a n tuples last) +(define (begin-val a n tuples last) + (if (null? tuples) + (if (and last (= n 1)) + `(call (top beginindex) ,a) + `(call (top first) (call (top axes) ,a ,n))) + (let ((dimno `(call (top +) ,(- n (length tuples)) + ,.(map (lambda (t) `(call (top length) ,t)) + tuples)))) + `(call (top first) (call (top axes) ,a ,dimno))))) + +;; replace `begin` and `end` for the closest ref expression, so doesn't go inside nested refs +(define (replace-beginend ex a n tuples last) (cond ((eq? ex 'end) (end-val a n tuples last)) + ((eq? ex 'begin) (begin-val a n tuples last)) ((or (atom? ex) (quoted? ex)) ex) ((eq? (car ex) 'ref) ;; inside ref only replace within the first argument - (list* 'ref (replace-end (cadr ex) a n tuples last) + (list* 'ref (replace-beginend (cadr ex) a n tuples last) (cddr ex))) (else (cons (car ex) - (map (lambda (x) (replace-end x a n tuples last)) + (map (lambda (x) (replace-beginend x a n tuples last)) (cdr ex)))))) -;; go through indices and replace the `end` symbol +;; go through indices and replace the `begin` or `end` symbol ;; a = array being indexed, i = list of indices ;; returns (values index-list stmts) where stmts are statements that need ;; to execute first. @@ -133,17 +144,17 @@ (loop (cdr lst) (+ n 1) stmts (cons (cadr idx) tuples) - (cons `(... ,(replace-end (cadr idx) a n tuples last)) + (cons `(... ,(replace-beginend (cadr idx) a n tuples last)) ret)) (let ((g (make-ssavalue))) (loop (cdr lst) (+ n 1) - (cons `(= ,g ,(replace-end (cadr idx) a n tuples last)) + (cons `(= ,g ,(replace-beginend (cadr idx) a n tuples last)) stmts) (cons g tuples) (cons `(... ,g) ret)))) (loop (cdr lst) (+ n 1) stmts tuples - (cons (replace-end idx a n tuples last) ret))))))) + (cons (replace-beginend idx a n tuples last) ret))))))) ;; GF method does not need to keep decl expressions on lambda args ;; except for rest arg @@ -1499,7 +1510,8 @@ (idxs (cddr e))) (let* ((reuse (and (pair? a) (contains (lambda (x) - (or (eq? x 'end) + (or (eq? x 'begin) + (eq? x 'end) (eq? x ':) (and (pair? x) (eq? (car x) ':)))) @@ -1514,7 +1526,7 @@ (define (expand-update-operator op op= lhs rhs . declT) (cond ((and (pair? lhs) (eq? (car lhs) 'ref)) - ;; expand indexing inside op= first, to remove "end" and ":" + ;; expand indexing inside op= first, to remove "begin", "end", and ":" (let* ((ex (partially-expand-ref lhs)) (stmts (butlast (cdr ex))) (refex (last (cdr ex))) diff --git a/stdlib/Base64/src/buffer.jl b/stdlib/Base64/src/buffer.jl index 40917a12eaadf..97ce82bf40030 100644 --- a/stdlib/Base64/src/buffer.jl +++ b/stdlib/Base64/src/buffer.jl @@ -15,9 +15,10 @@ end Base.empty!(buffer::Buffer) = buffer.size = 0 Base.getindex(buffer::Buffer, i::Integer) = unsafe_load(buffer.ptr, i) Base.setindex!(buffer::Buffer, v::UInt8, i::Integer) = unsafe_store!(buffer.ptr, v, i) -Base.endof(buffer::Buffer) = buffer.size +Base.beginindex(buffer::Buffer) = 1 +Base.endindex(buffer::Buffer) = buffer.size Base.pointer(buffer::Buffer) = buffer.ptr -capacity(buffer::Buffer) = Int(pointer(buffer.data, endof(buffer.data) + 1) - buffer.ptr) +capacity(buffer::Buffer) = Int(pointer(buffer.data, endindex(buffer.data) + 1) - buffer.ptr) function consumed!(buffer::Buffer, n::Integer) @assert n ≤ buffer.size diff --git a/stdlib/Base64/src/decode.jl b/stdlib/Base64/src/decode.jl index e1741f270c5bc..017c015b04bec 100644 --- a/stdlib/Base64/src/decode.jl +++ b/stdlib/Base64/src/decode.jl @@ -77,7 +77,7 @@ function read_until_end(pipe::Base64DecodePipe, ptr::Ptr{UInt8}, n::UInt) end end if p < p_end - if i + 4 ≤ endof(buffer) + if i + 4 ≤ endindex(buffer) b1 = decode(buffer[i+1]) b2 = decode(buffer[i+2]) b3 = decode(buffer[i+3]) @@ -140,7 +140,7 @@ function decode_slow(b1, b2, b3, b4, buffer, i, input, ptr, n, rest) else break end - if i + 1 ≤ endof(buffer) + if i + 1 ≤ endindex(buffer) b4 = decode(buffer[i+=1]) elseif !eof(input) b4 = decode(read(input, UInt8)) diff --git a/stdlib/Dates/src/io.jl b/stdlib/Dates/src/io.jl index 6d77e845d36bc..8a4154ab72702 100644 --- a/stdlib/Dates/src/io.jl +++ b/stdlib/Dates/src/io.jl @@ -154,7 +154,7 @@ end # the last n digits of y # will be 0 padded if y has less than n digits str = dec(y, n) - l = endof(str) + l = endindex(str) if l == n # fast path write(io, str) @@ -348,7 +348,7 @@ function DateFormat(f::AbstractString, locale::DateLocale=ENGLISH) prev_offset = m.offset + width end - tran = replace(f[prev_offset:endof(f)], r"\\(.)" => s"\1") + tran = replace(f[prev_offset:endindex(f)], r"\\(.)" => s"\1") if !isempty(prev) letter, width = prev diff --git a/stdlib/Dates/src/parse.jl b/stdlib/Dates/src/parse.jl index 5f8698291ca36..1388769ceba8d 100644 --- a/stdlib/Dates/src/parse.jl +++ b/stdlib/Dates/src/parse.jl @@ -198,7 +198,7 @@ end end function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeFormat)) - i, end_pos = start(s), endof(s) + i, end_pos = start(s), endindex(s) dm = dd = Int64(1) th = tm = ts = tms = Int64(0) @@ -265,13 +265,13 @@ function Base.parse(::Type{DateTime}, s::AbstractString, df::typeof(ISODateTimeF end function Base.parse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType - pos, len = start(str), endof(str) + pos, len = start(str), endindex(str) values, pos = tryparsenext_internal(T, str, pos, len, df, true) T(values...) end function Base.tryparse(::Type{T}, str::AbstractString, df::DateFormat=default_format(T)) where T<:TimeType - pos, len = start(str), endof(str) + pos, len = start(str), endindex(str) values, pos = tryparsenext_internal(T, str, pos, len, df, false) if values === nothing nothing @@ -296,7 +296,7 @@ number of components may be less than the total number of `DatePart`. tokens = Type[CONVERSION_SPECIFIERS[letter] for letter in letters] quote - pos, len = start(str), endof(str) + pos, len = start(str), endindex(str) values, pos, num_parsed = tryparsenext_core(str, pos, len, df, true) t = values types = $(Expr(:tuple, tokens...)) diff --git a/stdlib/DelimitedFiles/src/DelimitedFiles.jl b/stdlib/DelimitedFiles/src/DelimitedFiles.jl index 714b02b4ee609..b61cc38b0fd6b 100644 --- a/stdlib/DelimitedFiles/src/DelimitedFiles.jl +++ b/stdlib/DelimitedFiles/src/DelimitedFiles.jl @@ -381,7 +381,7 @@ function store_cell(dlmstore::DLMStore{T}, row::Int, col::Int, # fill data if quoted && _chrinstr(sbuff, UInt8('"'), startpos, endpos) unescaped = replace(SubString(sbuff, startpos, endpos), r"\"\"" => "\"") - fail = colval(unescaped, 1, endof(unescaped), cells, drow, col) + fail = colval(unescaped, 1, endindex(unescaped), cells, drow, col) else fail = colval(sbuff, startpos, endpos, cells, drow, col) end @@ -400,7 +400,7 @@ function store_cell(dlmstore::DLMStore{T}, row::Int, col::Int, # fill header if quoted && _chrinstr(sbuff, UInt8('"'), startpos, endpos) unescaped = replace(SubString(sbuff, startpos, endpos), r"\"\"" => "\"") - colval(unescaped, 1, endof(unescaped), dlmstore.hdr, 1, col) + colval(unescaped, 1, endindex(unescaped), dlmstore.hdr, 1, col) else colval(sbuff, startpos, endpos, dlmstore.hdr, 1, col) end diff --git a/test/char.jl b/test/char.jl index c5e98d302e41b..a57633326e9ed 100644 --- a/test/char.jl +++ b/test/char.jl @@ -88,9 +88,9 @@ let @test length(x) == 1 end - #endof(c::Char) = 1 + #endindex(c::Char) = 1 for x in testarrays - @test endof(x) == 1 + @test endindex(x) == 1 end #getindex(c::Char) = c diff --git a/test/dict.jl b/test/dict.jl index d3df55dab77a1..ff9f516a1d8e6 100644 --- a/test/dict.jl +++ b/test/dict.jl @@ -10,7 +10,7 @@ @test !done(p,2) @test done(p,3) @test !done(p,0) - @test endof(p) == length(p) == 2 + @test endindex(p) == length(p) == 2 @test Base.indexed_next(p, 1, (1,2)) == (10,2) @test Base.indexed_next(p, 2, (1,2)) == (20,3) @test (1=>2) < (2=>3) @@ -541,13 +541,13 @@ import Base.== const global hashoffset = [UInt(190)] Base.hash(s::MyString) = hash(s.str) + hashoffset[] -Base.endof(s::MyString) = endof(s.str) +Base.endindex(s::MyString) = endindex(s.str) Base.next(s::MyString, v::Int) = next(s.str, v) Base.isequal(a::MyString, b::MyString) = isequal(a.str, b.str) ==(a::MyString, b::MyString) = (a.str == b.str) Base.hash(v::MyInt) = v.val + hashoffset[] -Base.endof(v::MyInt) = endof(v.val) +Base.endindex(v::MyInt) = endindex(v.val) Base.next(v::MyInt, i::Int) = next(v.val, i) Base.isequal(a::MyInt, b::MyInt) = isequal(a.val, b.val) ==(a::MyInt, b::MyInt) = (a.val == b.val) diff --git a/test/numbers.jl b/test/numbers.jl index dd9adc60ebae4..9a1f3d858b22d 100644 --- a/test/numbers.jl +++ b/test/numbers.jl @@ -2855,7 +2855,7 @@ end @test !isinteger(π) @test size(1) == () @test length(1) == 1 - @test endof(1) == 1 + @test endindex(1) == 1 @test eltype(Integer) == Integer end # issue #15920 diff --git a/test/offsetarray.jl b/test/offsetarray.jl index f27a59983eb3b..494c986c33cab 100644 --- a/test/offsetarray.jl +++ b/test/offsetarray.jl @@ -312,7 +312,7 @@ a = OffsetArray(a0, (-1,2,3,4,5)) # other functions v = OffsetArray(v0, (-3,)) -@test endof(v) == 1 +@test endindex(v) == 1 @test v ≈ v @test axes(v') === (Base.OneTo(1),-2:1) @test parent(v) == collect(v) diff --git a/test/operators.jl b/test/operators.jl index 96c0f538ad2bf..a143710f3d4fa 100644 --- a/test/operators.jl +++ b/test/operators.jl @@ -45,8 +45,8 @@ p = 1=>:foo @test last(p) == :foo @test first(reverse(p)) == :foo @test last(reverse(p)) == 1 -@test endof(p) == 2 -@test p[endof(p)] == p[end] == p[2] == :foo +@test endindex(p) == 2 +@test p[endindex(p)] == p[end] == p[2] == :foo @test (|)(2) == 2 @test xor(2) == 2 diff --git a/test/parse.jl b/test/parse.jl index a510e804ac5e4..fc4c86cf63c7c 100644 --- a/test/parse.jl +++ b/test/parse.jl @@ -75,7 +75,7 @@ for T in vcat(subtypes(Signed), subtypes(Unsigned)) # Test that the entire input string appears in error messages let s = " false true " result = @test_throws(ArgumentError, - Base.tryparse_internal(Bool, s, start(s), endof(s), 0, true)) + Base.tryparse_internal(Bool, s, start(s), endindex(s), 0, true)) @test result.value.msg == "invalid Bool representation: $(repr(s))" end diff --git a/test/read.jl b/test/read.jl index b6b6fef9bebd2..dc92fdfb3b469 100644 --- a/test/read.jl +++ b/test/read.jl @@ -163,7 +163,7 @@ for (name, f) in l ("barbarbarians", "barbarian", "barbarbarian")] local t, s, m @test readuntil(io(t), s) == m - @test readuntil(io(t), SubString(s, start(s), endof(s))) == m + @test readuntil(io(t), SubString(s, start(s), endindex(s))) == m @test readuntil(io(t), GenericString(s)) == m @test readuntil(io(t), unsafe_wrap(Vector{UInt8},s)) == unsafe_wrap(Vector{UInt8},m) @test readuntil(io(t), collect(s)::Vector{Char}) == Vector{Char}(m) diff --git a/test/replcompletions.jl b/test/replcompletions.jl index 116296ba3bb42..b7b449e49e654 100644 --- a/test/replcompletions.jl +++ b/test/replcompletions.jl @@ -97,9 +97,9 @@ function temp_pkg_dir_noinit(fn::Function) end end -test_complete(s) = completions(s,endof(s)) -test_scomplete(s) = shell_completions(s,endof(s)) -test_bslashcomplete(s) = bslash_completions(s,endof(s))[2] +test_complete(s) = completions(s,endindex(s)) +test_scomplete(s) = shell_completions(s,endindex(s)) +test_bslashcomplete(s) = bslash_completions(s,endindex(s))[2] let s = "" c, r = test_complete(s) @@ -442,35 +442,35 @@ end let s = "(1+2im)." c,r = test_complete(s) @test length(c) == 2 - @test r == (endof(s) + 1):endof(s) + @test r == (endindex(s) + 1):endindex(s) @test c == ["im", "re"] end let s = "((1+2im))." c, r = test_complete(s) @test length(c) == 2 - @test r == (endof(s) + 1):endof(s) + @test r == (endindex(s) + 1):endindex(s) @test c == ["im", "re"] end let s = "CompletionFoo.test_y_array[1]." c, r = test_complete(s) @test length(c) == 1 - @test r == (endof(s) + 1):endof(s) + @test r == (endindex(s) + 1):endindex(s) @test c[1] == "yy" end let s = "CompletionFoo.Test_y(rand()).y" c, r = test_complete(s) @test length(c) == 1 - @test r == endof(s):endof(s) + @test r == endindex(s):endindex(s) @test c[1] == "yy" end let s = "CompletionFoo.test6()[1](CompletionFoo.Test_y(rand())).y" c, r = test_complete(s) @test length(c) == 1 - @test r == endof(s):endof(s) + @test r == endindex(s):endindex(s) @test c[1] == "yy" end @@ -717,12 +717,12 @@ let path = tempdir(), open(joinpath(space_folder, "space .file"),"w") do f s = Sys.iswindows() ? "rm $dir_space\\\\space" : "cd $dir_space/space" c,r = test_scomplete(s) - @test r == endof(s)-4:endof(s) + @test r == endindex(s)-4:endindex(s) @test "space\\ .file" in c s = Sys.iswindows() ? "cd(\"β $dir_space\\\\space" : "cd(\"β $dir_space/space" c,r = test_complete(s) - @test r == endof(s)-4:endof(s) + @test r == endindex(s)-4:endindex(s) @test "space\\ .file\"" in c end # Test for issue #10324 @@ -829,7 +829,7 @@ function test_dict_completion(dict_name) c, r = test_complete(s) @test c == Any["\"abcd\"]"] s = "$dict_name[\"abcd]" # trailing close bracket - c, r = completions(s, endof(s) - 1) + c, r = completions(s, endindex(s) - 1) @test c == Any["\"abcd\""] s = "$dict_name[:b" c, r = test_complete(s) diff --git a/test/strings/basic.jl b/test/strings/basic.jl index aba06f60dd769..e501aec537f2d 100644 --- a/test/strings/basic.jl +++ b/test/strings/basic.jl @@ -164,11 +164,11 @@ end let srep = repeat("Σβ",2) s="Σβ" - ss=SubString(s,1,endof(s)) + ss=SubString(s,1,endindex(s)) @test repeat(ss,2) == "ΣβΣβ" - @test endof(srep) == 7 + @test endindex(srep) == 7 @test next(srep, 3) == ('β',5) @test next(srep, 7) == ('β',9) @@ -215,7 +215,7 @@ end @test_throws MethodError isvalid(tstr, true) @test_throws MethodError next(tstr, 1) @test_throws MethodError next(tstr, true) - @test_throws MethodError endof(tstr) + @test_throws MethodError endindex(tstr) gstr = GenericString("12") @test string(gstr) isa GenericString @@ -442,9 +442,9 @@ end @test_throws ArgumentError ascii("Hello, ∀") @test_throws ArgumentError ascii(GenericString("Hello, ∀")) end -@testset "issue #17271: endof() doesn't throw an error even with invalid strings" begin - @test endof("\x90") == 1 - @test endof("\xce") == 1 +@testset "issue #17271: endindex() doesn't throw an error even with invalid strings" begin + @test endindex("\x90") == 1 + @test endindex("\xce") == 1 end # issue #17624, missing getindex method for String @test "abc"[:] == "abc" @@ -452,8 +452,8 @@ end @testset "issue #18280: next/nextind must return past String's underlying data" begin for s in ("Hello", "Σ", "こんにちは", "😊😁") local s - @test next(s, endof(s))[2] > sizeof(s) - @test nextind(s, endof(s)) > sizeof(s) + @test next(s, endindex(s))[2] > sizeof(s) + @test nextind(s, endindex(s)) > sizeof(s) end end # Test cmp with AbstractStrings that don't index the same as UTF-8, which would include @@ -466,7 +466,7 @@ end Base.start(x::CharStr) = start(x.chars) Base.next(x::CharStr, i::Int) = next(x.chars, i) Base.done(x::CharStr, i::Int) = done(x.chars, i) -Base.endof(x::CharStr) = endof(x.chars) +Base.endindex(x::CharStr) = endindex(x.chars) @testset "cmp without UTF-8 indexing" begin # Simple case, with just ANSI Latin 1 characters @test "áB" != CharStr("áá") # returns false with bug diff --git a/test/strings/search.jl b/test/strings/search.jl index 8d499207589eb..871521b17ecd5 100644 --- a/test/strings/search.jl +++ b/test/strings/search.jl @@ -39,8 +39,8 @@ for str in [astr, GenericString(astr)] @test findnext(equalto(','), str, 7) == 0 @test findfirst(equalto('\n'), str) == 14 @test findnext(equalto('\n'), str, 15) == 0 - @test_throws BoundsError findnext(equalto('ε'), str, nextind(str,endof(str))+1) - @test_throws BoundsError findnext(equalto('a'), str, nextind(str,endof(str))+1) + @test_throws BoundsError findnext(equalto('ε'), str, nextind(str,endindex(str))+1) + @test_throws BoundsError findnext(equalto('a'), str, nextind(str,endindex(str))+1) end # ascii backward search @@ -85,10 +85,10 @@ for str in (u8str, GenericString(u8str)) @test findfirst(equalto('ε'), str) == 5 @test findnext(equalto('ε'), str, nextind(str,5)) == 54 @test findnext(equalto('ε'), str, nextind(str,54)) == 0 - @test findnext(equalto('ε'), str, nextind(str,endof(str))) == 0 - @test findnext(equalto('a'), str, nextind(str,endof(str))) == 0 - @test_throws BoundsError findnext(equalto('ε'), str, nextind(str,endof(str))+1) - @test_throws BoundsError findnext(equalto('a'), str, nextind(str,endof(str))+1) + @test findnext(equalto('ε'), str, nextind(str,endindex(str))) == 0 + @test findnext(equalto('a'), str, nextind(str,endindex(str))) == 0 + @test_throws BoundsError findnext(equalto('ε'), str, nextind(str,endindex(str))+1) + @test_throws BoundsError findnext(equalto('a'), str, nextind(str,endindex(str))+1) end # utf-8 backward search @@ -192,38 +192,38 @@ end @test findfirst(r"ε", u8str) == 5:5 @test findnext(r"ε", u8str, 7) == 54:54 @test findnext(r"ε", u8str, 56) == 0:-1 -for i = 1:endof(astr) +for i = 1:endindex(astr) @test findnext(r"."s, astr, i) == i:i end -for i = 1:endof(u8str) +for i = 1:endindex(u8str) if isvalid(u8str,i) @test findnext(r"."s, u8str, i) == i:i end end # string forward search with a zero-char string -for i = 1:endof(astr) +for i = 1:endindex(astr) @test findnext("", astr, i) == i:i-1 end -for i = 1:endof(u8str) +for i = 1:endindex(u8str) @test findnext("", u8str, i) == i:i-1 end @test findfirst("", "") == 1:0 # string backward search with a zero-char string -for i = 1:endof(astr) +for i = 1:endindex(astr) @test findprev("", astr, i) == i:i-1 end -for i = 1:endof(u8str) +for i = 1:endindex(u8str) @test findprev("", u8str, i) == i:i-1 end @test findlast("", "") == 1:0 # string forward search with a zero-char regex -for i = 1:endof(astr) +for i = 1:endindex(astr) @test findnext(r"", astr, i) == i:i-1 end -for i = 1:endof(u8str) +for i = 1:endindex(u8str) # TODO: should regex search fast-forward invalid indices? if isvalid(u8str,i) @test findnext(r"", u8str, i) == i:i-1 @@ -267,23 +267,23 @@ end # string backward search with a two-char UTF-8 (2 byte) string literal @test findlast("éé", "ééé") == 3:5 -@test findprev("éé", "ééé", endof("ééé")) == 3:5 +@test findprev("éé", "ééé", endindex("ééé")) == 3:5 # string backward search with a two-char UTF-8 (3 byte) string literal @test findlast("€€", "€€€") == 4:7 -@test findprev("€€", "€€€", endof("€€€")) == 4:7 +@test findprev("€€", "€€€", endindex("€€€")) == 4:7 # string backward search with a two-char UTF-8 (4 byte) string literal @test findlast("\U1f596\U1f596", "\U1f596\U1f596\U1f596") == 5:9 -@test findprev("\U1f596\U1f596", "\U1f596\U1f596\U1f596", endof("\U1f596\U1f596\U1f596")) == 5:9 +@test findprev("\U1f596\U1f596", "\U1f596\U1f596\U1f596", endindex("\U1f596\U1f596\U1f596")) == 5:9 # string backward search with a two-char UTF-8 (2 byte) string literal @test findlast("éé", "éé") == 1:3 # should really be 1:4! -@test findprev("éé", "éé", endof("ééé")) == 1:3 +@test findprev("éé", "éé", endindex("ééé")) == 1:3 # string backward search with a two-char UTF-8 (3 byte) string literal @test findlast("€€", "€€") == 1:4 # should really be 1:6! -@test findprev("€€", "€€", endof("€€€")) == 1:4 +@test findprev("€€", "€€", endindex("€€€")) == 1:4 # string backward search with a two-char UTF-8 (4 byte) string literal @test findlast("\U1f596\U1f596", "\U1f596\U1f596") == 1:5 # should really be 1:8! -@test findprev("\U1f596\U1f596", "\U1f596\U1f596", endof("\U1f596\U1f596\U1f596")) == 1:5 +@test findprev("\U1f596\U1f596", "\U1f596\U1f596", endindex("\U1f596\U1f596\U1f596")) == 1:5 # string backward search with a two-char string literal @test findlast("xx", "foo,bar,baz") == 0:-1 diff --git a/test/strings/types.jl b/test/strings/types.jl index 0eefac0549c3c..5e3f1d6bcc738 100644 --- a/test/strings/types.jl +++ b/test/strings/types.jl @@ -55,7 +55,7 @@ for idx in [0, 1, 4] @test SubString("∀∀", 4, idx) == "∀∀"[4:idx] end -# index beyond endof("∀∀") +# index beyond endindex("∀∀") for idx in [2:3; 5:6] @test_throws StringIndexError SubString("∀∀", 1, idx) end @@ -64,10 +64,10 @@ for idx in 7:8 end let str="tempus fugit" #length(str)==12 - ss=SubString(str,1,endof(str)) #match source string + ss=SubString(str,1,endindex(str)) #match source string @test length(ss)==length(str) - ss=SubString(str,1:endof(str)) + ss=SubString(str,1:endindex(str)) @test length(ss)==length(str) ss=SubString(str,1,0) #empty SubString @@ -241,8 +241,8 @@ end @test c == s[reverseind(s, ri)] == r[ri] s = convert(T, string(prefix, prefix, c, suffix, suffix)) pre = convert(T, prefix) - sb = SubString(s, nextind(pre, endof(pre)), - endof(convert(T, string(prefix, prefix, c, suffix)))) + sb = SubString(s, nextind(pre, endindex(pre)), + endindex(convert(T, string(prefix, prefix, c, suffix)))) r = reverse(sb) ri = findfirst(equalto(c), r) @test c == sb[reverseind(sb, ri)] == r[ri] diff --git a/test/tuple.jl b/test/tuple.jl index 74becec9e6401..556946ec32e3e 100644 --- a/test/tuple.jl +++ b/test/tuple.jl @@ -95,9 +95,9 @@ end @test_throws ArgumentError Base.front(()) @test_throws ArgumentError first(()) - @test endof(()) === 0 - @test endof((1,)) === 1 - @test endof((1,2)) === 2 + @test endindex(()) === 0 + @test endindex((1,)) === 1 + @test endindex((1,2)) === 2 @test size((), 1) === 0 @test size((1,), 1) === 1