Rename inds->indices

Author: timholy

base/abstractarray.jl

@@ -21,8 +21,8 @@ end
 
 size{T,n}(t::AbstractArray{T,n}, d) = d <= n ? size(t)[d] : 1
 size(x, d1::Integer, d2::Integer, dx::Integer...) = tuple(size(x, d1), size(x, d2, dx...)...)
-inds(A::AbstractArray, d) = 1:size(A,d)
-inds{T,N}(A::AbstractArray{T,N}) = ntuple(d->inds(A, d), Val{N})
+indices(A::AbstractArray, d) = 1:size(A,d)
+indices{T,N}(A::AbstractArray{T,N}) = ntuple(d->indices(A, d), Val{N})
 eltype{T}(::Type{AbstractArray{T}}) = T
 eltype{T,n}(::Type{AbstractArray{T,n}}) = T
 elsize{T}(::AbstractArray{T}) = sizeof(T)
@@ -106,7 +106,7 @@ function checkbounds(::Type{Bool}, inds::UnitRange, r::Range)
     @_propagate_inbounds_meta
     isempty(r) | (checkbounds(Bool, inds, first(r)) & checkbounds(Bool, inds, last(r)))
 end
-checkbounds{N}(::Type{Bool}, indx::UnitRange, I::AbstractArray{Bool,N}) = N == 1 && indx == inds(I,1)
+checkbounds{N}(::Type{Bool}, indx::UnitRange, I::AbstractArray{Bool,N}) = N == 1 && indx == indices(I,1)
 function checkbounds(::Type{Bool}, inds::UnitRange, I::AbstractArray)
     @_inline_meta
     b = true
@@ -138,13 +138,13 @@ checkbounds(A::AbstractArray, I...) = (@_inline_meta; _internal_checkbounds(A, I
 # The internal function is named _internal_checkbounds since there had been a
 # _checkbounds previously that meant something different.
 _internal_checkbounds(A::AbstractArray) = true
-_internal_checkbounds(A::AbstractArray, I::AbstractArray{Bool}) = inds(A) == inds(I) || throw_boundserror(A, I)
-_internal_checkbounds(A::AbstractVector, I::AbstractVector{Bool}) = inds(A) == inds(I) || throw_boundserror(A, I)
+_internal_checkbounds(A::AbstractArray, I::AbstractArray{Bool}) = indices(A) == indices(I) || throw_boundserror(A, I)
+_internal_checkbounds(A::AbstractVector, I::AbstractVector{Bool}) = indices(A) == indices(I) || throw_boundserror(A, I)
 _internal_checkbounds(A::AbstractArray, I::AbstractVector{Bool}) = length(A) == length(I) || throw_boundserror(A, I)
 function _internal_checkbounds(A::AbstractArray, I1, I...)
     # having I1 seems important for good codegen
     @_inline_meta
-    checkbounds(Bool, inds(A), I1, I...) || throw_boundserror(A, (I1, I...))
+    checkbounds(Bool, indices(A), I1, I...) || throw_boundserror(A, (I1, I...))
 end
 
 # See also specializations in multidimensional
@@ -568,9 +568,9 @@ end
 
 typealias RangeVecIntList{A<:AbstractVector{Int}} Union{Tuple{Vararg{Union{Range, AbstractVector{Int}}}}, AbstractVector{UnitRange{Int}}, AbstractVector{Range{Int}}, AbstractVector{A}}
 
-get(A::AbstractArray, i::Integer, default) = checkbounds(Bool, inds(A), i) ? A[i] : default
+get(A::AbstractArray, i::Integer, default) = checkbounds(Bool, indices(A), i) ? A[i] : default
 get(A::AbstractArray, I::Tuple{}, default) = similar(A, typeof(default), 0)
-get(A::AbstractArray, I::Dims, default) = checkbounds(Bool, inds(A), I...) ? A[I...] : default
+get(A::AbstractArray, I::Dims, default) = checkbounds(Bool, indices(A), I...) ? A[I...] : default
 
 function get!{T}(X::AbstractArray{T}, A::AbstractArray, I::Union{Range, AbstractVector{Int}}, default::T)
     ind = findin(I, 1:length(A))

base/deprecated.jl

@@ -1124,11 +1124,11 @@ end
 @deprecate_binding ByteString String
 
 function checkbounds(::Type{Bool}, sz::Integer, i)
-    depwarn("checkbounds(Bool, size(A, d), i) is deprecated, use checkbounds(Bool, inds(A, d), i).", :checkbounds)
+    depwarn("checkbounds(Bool, size(A, d), i) is deprecated, use checkbounds(Bool, indices(A, d), i).", :checkbounds)
     checkbounds(Bool, 1:sz, i)
 end
 function checkbounds{N,T}(::Type{Bool}, sz::NTuple{N,Integer}, I1::T, I...)
-    depwarn("checkbounds(Bool, size(A), I...) is deprecated, use checkbounds(Bool, inds(A), I...).", :checkbounds)
+    depwarn("checkbounds(Bool, size(A), I...) is deprecated, use checkbounds(Bool, indices(A), I...).", :checkbounds)
     checkbounds(Bool, map(s->1:s, sz), I1, I...)
 end
 

base/exports.jl

@@ -537,9 +537,9 @@ export
     hvcat,
     ind2sub,
     indexin,
+    indices,
     indmax,
     indmin,
-    inds,
     invperm,
     ipermute!,
     ipermutedims,

base/multidimensional.jl

@@ -193,7 +193,7 @@ using .IteratorsMD
 for N = 1:5
     args = [:($(Symbol(:I, d))) for d = 1:N]
     targs = [:($(Symbol(:I, d))::Union{Colon,Number,AbstractArray}) for d = 1:N]  # prevent co-opting the CartesianIndex version
-    exs = [:(checkbounds(Bool, inds(A, $d), $(args[d]))) for d = 1:N]
+    exs = [:(checkbounds(Bool, indices(A, $d), $(args[d]))) for d = 1:N]
     cbexpr = exs[1]
     for d = 2:N
         cbexpr = :($(exs[d]) & $cbexpr)

test/abstractarray.jl

@@ -534,9 +534,9 @@ OffsetArray{T,N}(A::AbstractArray{T,N}, offsets::NTuple{N,Int}) = OffsetArray{T,
 
 Base.parent(A::OffsetArray) = A.parent
 Base.size(A::OffsetArray) = size(parent(A))
-Base.inds(A::OffsetArray, d) = (1:size(parent(A),d))+A.offsets[d]
-Base.eachindex(A::OffsetArray) = CartesianRange(inds(A))
-Base.summary(A::OffsetArray) = string(typeof(A))*" with inds "*string(inds(A))
+Base.indices(A::OffsetArray, d) = (1:size(parent(A),d))+A.offsets[d]
+Base.eachindex(A::OffsetArray) = CartesianRange(indices(A))
+Base.summary(A::OffsetArray) = string(typeof(A))*" with indices "*string(indices(A))
 
 @inline function Base.getindex{T,N}(A::OffsetArray{T,N}, I::Vararg{Int,N})
     @boundscheck checkbounds(A, I...)