get rid of extra naming

Author: ChrisRackauckas

docs/make.jl

@@ -1,20 +1,11 @@
-using ArrayInterface
-using Pkg
-
-function dev_subpkg(subpkg)
-    subpkg_path = joinpath(dirname(@__DIR__), "lib", subpkg)
-    Pkg.develop(PackageSpec(path=subpkg_path))
-end
-dev_subpkg("ArrayInterfaceCore")
-
-using ArrayInterfaceCore
+using StaticArrayInterface
 using Documenter
 
 makedocs(;
-    modules=[ArrayInterface, ArrayInterfaceCore],
-    sitename="ArrayInterface",
+    modules=[StaticArrayInterface],
+    sitename="StaticArrayInterface.jl",
     pages=[
-        "Home" => "index.md",
+        "StaticArrayInterface.jl: Static Compile-Time Enforced Array Interface Functionality" => "index.md",
         "API" => "api.md"
     ]
 )

src/StaticArrayInterface.jl

@@ -47,22 +47,22 @@ import Compat
     Tuple{X.parameters..., Y.parameters...}
 end
 
-Base.size(A::AbstractArray2) = map(Int, ArrayInterface.static_size(A))
-Base.size(A::AbstractArray2, dim) = Int(ArrayInterface.static_size(A, dim))
+Base.size(A::AbstractArray2) = map(Int, static_size(A))
+Base.size(A::AbstractArray2, dim) = Int(static_size(A, dim))
 
 function Base.axes(A::AbstractArray2)
-    is_forwarding_wrapper(A) && return ArrayInterface.static_axes(parent(A))
+    is_forwarding_wrapper(A) && return static_axes(parent(A))
     throw(ArgumentError("Subtypes of `AbstractArray2` must define an axes method"))
 end
 function Base.axes(A::AbstractArray2, dim::Union{Symbol, StaticSymbol})
     static_axes(A, to_dims(A, dim))
 end
 
 function Base.strides(A::AbstractArray2)
-    defines_strides(A) && return map(Int, ArrayInterface.static_strides(A))
+    defines_strides(A) && return map(Int, static_strides(A))
     throw(MethodError(Base.strides, (A,)))
 end
-Base.strides(A::AbstractArray2, dim) = Int(ArrayInterface.static_strides(A, dim))
+Base.strides(A::AbstractArray2, dim) = Int(static_strides(A, dim))
 
 function Base.IndexStyle(::Type{T}) where {T <: AbstractArray2}
     is_forwarding_wrapper(T) ? IndexStyle(parent_type(T)) : IndexCartesian()
@@ -121,14 +121,14 @@ Examples
      1 - 1im
      1 + 1im
 
-    julia> ArrayInterface.is_lazy_conjugate(a)
+    julia> is_lazy_conjugate(a)
     True()
 
     julia> b = a'
     1×2 adjoint(transpose(adjoint(::Vector{Complex{Int64}}))) with eltype Complex{Int64}:
      1+1im  1-1im
 
-    julia> ArrayInterface.is_lazy_conjugate(b)
+    julia> is_lazy_conjugate(b)
     False()
 
 """

src/axes.jl

@@ -102,8 +102,8 @@ end
     static_axes(A, dim) -> AbstractUnitRange{Int}
 
 Returns the axis associated with each dimension of `A` or dimension `dim`.
-`ArrayInterface.static_axes(::AbstractArray)` behaves nearly identical to `Base.axes` with the
-exception of a handful of types replace `Base.OneTo{Int}` with `ArrayInterface.SOneTo`. For
+`static_axes(::AbstractArray)` behaves nearly identical to `Base.axes` with the
+exception of a handful of types replace `Base.OneTo{Int}` with `SOneTo`. For
 example, the axis along the first dimension of `Transpose{T,<:AbstractVector{T}}` and
 `Adjoint{T,<:AbstractVector{T}}` can be represented by `SOneTo(1)`. Similarly,
 `Base.ReinterpretArray`'s first axis may be statically sized.
@@ -173,20 +173,20 @@ Base.IndexStyle(T::Type{<:LazyAxis}) = IndexStyle(parent_type(T))
 function Static.OptionallyStaticUnitRange(x::LazyAxis)
     OptionallyStaticUnitRange(static_first(x), static_last(x))
 end
-ArrayInterface.can_change_size(@nospecialize T::Type{<:LazyAxis}) = can_change_size(fieldtype(T, :parent))
+can_change_size(@nospecialize T::Type{<:LazyAxis}) = can_change_size(fieldtype(T, :parent))
 
-ArrayInterface.known_first(::Type{<:LazyAxis{N,P}}) where {N,P} = known_offsets(P, static(N))
-ArrayInterface.known_first(::Type{<:LazyAxis{:,P}}) where {P} = 1
+known_first(::Type{<:LazyAxis{N,P}}) where {N,P} = known_offsets(P, static(N))
+known_first(::Type{<:LazyAxis{:,P}}) where {P} = 1
 @inline function Base.first(x::LazyAxis{N})::Int where {N}
-    if ArrayInterface.known_first(x) === nothing
+    if known_first(x) === nothing
         return Int(offsets(getfield(x, :parent), StaticInt(N)))
     else
         return Int(known_first(x))
     end
 end
 @inline Base.first(x::LazyAxis{:})::Int = Int(offset1(getfield(x, :parent)))
-ArrayInterface.known_last(::Type{LazyAxis{N,P}}) where {N,P} = known_last(axes_types(P, static(N)))
-ArrayInterface.known_last(::Type{LazyAxis{:,P}}) where {P} = known_length(P)
+known_last(::Type{LazyAxis{N,P}}) where {N,P} = known_last(axes_types(P, static(N)))
+known_last(::Type{LazyAxis{:,P}}) where {P} = known_length(P)
 Base.last(x::LazyAxis) = _last(known_last(x), x)
 _last(::Nothing, x::LazyAxis{:}) = lastindex(getfield(x, :parent))
 _last(::Nothing, x::LazyAxis{N}) where {N} = lastindex(getfield(x, :parent), N)

src/broadcast.jl

@@ -11,9 +11,9 @@ to both `x` and `y` unless one has a length of `1`, in which case the longest ax
 equal to the output.
 
 ```julia
-julia> ArrayInterface.broadcast_axis(1:10, 1:10)
+julia> broadcast_axis(1:10, 1:10)
 
-julia> ArrayInterface.broadcast_axis(1:10, 1)
+julia> broadcast_axis(1:10, 1)
 1:10
 
 ```

src/indexing.jl

@@ -1,6 +1,6 @@
 
 """
-    ArrayInterface.static_to_indices(A, I::Tuple) -> Tuple
+    static_to_indices(A, I::Tuple) -> Tuple
 
 Converts the tuple of indexing arguments, `I`, into an appropriate form for indexing into `A`.
 Typically, each index should be an `Int`, `StaticInt`, a collection with values of `Int`, or a collection with values of `CartesianIndex`
@@ -29,14 +29,14 @@ This implementation differs from that of `Base.to_indices` in the following ways
     1.105 μs (12 allocations: 672 bytes)
     (1, 1, 2, 1, 1, 2, 1, 1, 2, 1)
 
-    julia> @btime ArrayInterface.static_to_indices(\$x, \$inds2)
+    julia> @btime static_to_indices(\$x, \$inds2)
     0.041 ns (0 allocations: 0 bytes)
     (1, 1, 2, 1, 1, 2, 1, 1, 2, 1)
 
     julia> @btime Base.to_indices(\$x, \$inds3);
     340.629 ns (14 allocations: 768 bytes)
 
-    julia> @btime ArrayInterface.static_to_indices(\$x, \$inds3);
+    julia> @btime static_to_indices(\$x, \$inds3);
     11.614 ns (0 allocations: 0 bytes)
 
     ```
@@ -80,41 +80,41 @@ end
 end
 
 """
-    ArrayInterface.to_index([::IndexStyle, ]axis, arg) -> index
+    to_index([::IndexStyle, ]axis, arg) -> index
 
-Convert the argument `arg` that was originally passed to `ArrayInterface.static_getindex` for the
+Convert the argument `arg` that was originally passed to `static_getindex` for the
 dimension corresponding to `axis` into a form for native indexing (`Int`, Vector{Int}, etc.).
 
-`ArrayInterface.to_index` supports passing a function as an index. This function-index is
+`to_index` supports passing a function as an index. This function-index is
 transformed into a proper index.
 
 ```julia
 julia> using ArrayInterface, Static
 
-julia> ArrayInterface.to_index(static(1):static(10), 5)
+julia> to_index(static(1):static(10), 5)
 5
 
-julia> ArrayInterface.to_index(static(1):static(10), <(5))
+julia> to_index(static(1):static(10), <(5))
 static(1):4
 
-julia> ArrayInterface.to_index(static(1):static(10), <=(5))
+julia> to_index(static(1):static(10), <=(5))
 static(1):5
 
-julia> ArrayInterface.to_index(static(1):static(10), >(5))
+julia> to_index(static(1):static(10), >(5))
 6:static(10)
 
-julia> ArrayInterface.to_index(static(1):static(10), >=(5))
+julia> to_index(static(1):static(10), >=(5))
 5:static(10)
 
 ```
 
 Use of a function-index helps ensure that indices are inbounds
 
 ```julia
-julia> ArrayInterface.to_index(static(1):static(10), <(12))
+julia> to_index(static(1):static(10), <(12))
 static(1):10
 
-julia> ArrayInterface.to_index(static(1):static(10), >(-1))
+julia> to_index(static(1):static(10), >(-1))
 1:static(10)
 ```
 
@@ -259,10 +259,10 @@ end
 to_axis(S::IndexLinear, axis, inds) = StaticInt(1):static_length(inds)
 
 """
-    ArrayInterface.static_getindex(A, args...)
+    static_getindex(A, args...)
 
 Retrieve the value(s) stored at the given key or index within a collection. Creating
-another instance of `ArrayInterface.static_getindex` should only be done by overloading `A`.
+another instance of `static_getindex` should only be done by overloading `A`.
 Changing indexing based on a given argument from `args` should be done through,
 [`to_index`](@ref), or [`to_axis`](@ref).
 """
@@ -380,7 +380,7 @@ _known_first_isone(ind) = known_first(ind) !== nothing && isone(known_first(ind)
 end
 
 """
-    ArrayInterface.setindex!(A, args...)
+    setindex!(A, args...)
 
 Store the given values at the given key or index within a collection.
 """
@@ -446,10 +446,10 @@ If `first` of an instance of type `T` is known at compile time, return it.
 Otherwise, return `nothing`.
 
 ```julia
-julia> ArrayInterface.known_first(typeof(1:4))
+julia> known_first(typeof(1:4))
 nothing
 
-julia> ArrayInterface.known_first(typeof(Base.OneTo(4)))
+julia> known_first(typeof(Base.OneTo(4)))
 1
 ```
 """
@@ -469,10 +469,10 @@ If `last` of an instance of type `T` is known at compile time, return it.
 Otherwise, return `nothing`.
 
 ```julia
-julia> ArrayInterface.known_last(typeof(1:4))
+julia> known_last(typeof(1:4))
 nothing
 
-julia> ArrayInterface.known_first(typeof(static(1):static(4)))
+julia> known_first(typeof(static(1):static(4)))
 4
 
 ```
@@ -490,10 +490,10 @@ If `step` of an instance of type `T` is known at compile time, return it.
 Otherwise, return `nothing`.
 
 ```julia
-julia> StaticArrayInterface.known_step(typeof(1:2:8))
+julia> known_step(typeof(1:2:8))
 nothing
 
-julia> StaticArrayInterface.known_step(typeof(1:4))
+julia> known_step(typeof(1:4))
 1
 
 ```

src/ranges.jl

@@ -1,11 +1,11 @@
 
-ArrayInterface.known_first(::Type{<:OptionallyStaticUnitRange{StaticInt{F}}}) where {F} = F::Int
-ArrayInterface.known_first(::Type{<:OptionallyStaticStepRange{StaticInt{F}}}) where {F} = F::Int
+known_first(::Type{<:OptionallyStaticUnitRange{StaticInt{F}}}) where {F} = F::Int
+known_first(::Type{<:OptionallyStaticStepRange{StaticInt{F}}}) where {F} = F::Int
 
-ArrayInterface.known_step(::Type{<:OptionallyStaticStepRange{<:Any,StaticInt{S}}}) where {S} = S::Int
+known_step(::Type{<:OptionallyStaticStepRange{<:Any,StaticInt{S}}}) where {S} = S::Int
 
-ArrayInterface.known_last(::Type{<:OptionallyStaticUnitRange{<:Any,StaticInt{L}}}) where {L} = L::Int
-ArrayInterface.known_last(::Type{<:OptionallyStaticStepRange{<:Any,<:Any,StaticInt{L}}}) where {L} = L::Int
+known_last(::Type{<:OptionallyStaticUnitRange{<:Any,StaticInt{L}}}) where {L} = L::Int
+known_last(::Type{<:OptionallyStaticStepRange{<:Any,<:Any,StaticInt{L}}}) where {L} = L::Int
 
 """
     indices(x, dim) -> AbstractUnitRange{Int}

src/size.jl

@@ -5,14 +5,14 @@
 
 Returns the size of each dimension of `A` or along dimension `dim` of `A`. If the size of
 any axes are known at compile time, these should be returned as `Static` numbers. Otherwise,
-`ArrayInterface.static_size(A)` is identical to `Base.size(A)`
+`static_size(A)` is identical to `Base.size(A)`
 
 ```julia
 julia> using StaticArrays, ArrayInterface
 
 julia> A = @SMatrix rand(3,4);
 
-julia> ArrayInterface.static_size(A)
+julia> static_size(A)
 (static(3), static(4))
 ```
 """
@@ -188,15 +188,15 @@ known_size(T::Type, dim::IntType) = ndims(T) < dim ? 1 : known_size(T)[dim]
     static_length(A) -> Union{Int,StaticInt}
 
 Returns the length of `A`.  If the length is known at compile time, it is
-returned as `Static` number.  Otherwise, `ArrayInterface.static_length(A)` is identical
+returned as `Static` number.  Otherwise, `static_length(A)` is identical
 to `Base.length(A)`.
 
 ```julia
 julia> using StaticArrays, ArrayInterface
 
 julia> A = @SMatrix rand(3,4);
 
-julia> ArrayInterface.static_length(A)
+julia> static_length(A)
 static(12)
 ```
 """

src/stridelayout.jl

@@ -485,7 +485,7 @@ these should be returned as `Static` numbers. For example:
 ```julia
 julia> A = rand(3,4);
 
-julia> ArrayInterface.static_strides(A)
+julia> static_strides(A)
 (static(1), 3)
 ```
 
@@ -494,7 +494,7 @@ Additionally, the behavior differs from `Base.strides` for adjoint vectors:
 ```julia
 julia> x = rand(5);
 
-julia> ArrayInterface.static_strides(x')
+julia> static_strides(x')
 (static(1), static(1))
 ```
 
@@ -519,7 +519,7 @@ _is_column_dense(::A) where {A<:AbstractArray} =
     defines_strides(A) &&
     (ndims(A) == 0 || Bool(is_dense(A)) && Bool(is_column_major(A)))
 
-# Fixes the example of https://github.com/JuliaArrays/ArrayInterface.jl/issues/160
+# Fixes the example of https://github.com/JuliaArrays/jl/issues/160
 function static_strides(A::ReshapedArray)
     if _is_column_dense(parent(A))
         return size_to_strides(static_size(A), One())