Prep for new release (#124)

* Prep for new release

Mostly moving static.jl to Static

* Fall back to Base.strides when define_strides(x) == false

* Took out reference to StaticInt

Documenting this is Static.jl's problem now

* Use Static comparison operators

* Use `defines_strides` to gate keep pointer assumptions

* DenseArray gets CPUPointer

* Add type stability check for axes_types(T, ::StaticInt)

* No recursion on device

Essentially equivalent to
```
function device(::Type{T}) where {T<:AbstractArray}
    if parent_type(T) <: T
        return T <: DenseArray ? CPUPointer() : CPUIndex()
    else
        if defines_strides(T)
            return device(parent_type(T))
        else
            out =  device(parent_type(T))
            return out isa CPUPointer ? CPUIndex() : out
        end
    end
end
```

* Refix fall back to Base.strides

* Ensure that strides(::AbstractArray2) doesn't recurse

Author: Tokazama

Project.toml

@@ -1,16 +1,18 @@
 name = "ArrayInterface"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "3.1.1"
+version = "3.1.2"
 
 [deps]
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
 
 [compat]
 IfElse = "0.1"
 Requires = "0.5, 1.0"
+Static = "0.1"
 julia = "1.2"
 
 [extras]

README.md

@@ -208,18 +208,6 @@ For example, if `A isa Base.Matrix`, `offsets(A) === (StaticInt(1), StaticInt(1)
 
 Is the function `f` whitelisted for `LoopVectorization.@avx`?
 
-## static(x)
-Returns a static form of `x`. If `x` is already in a static form then `x` is returned. If
-there is no static alternative for `x` then an error is thrown.
-
-## StaticInt(N::Int)
-
-Creates a static integer with value known at compile time. It is a number,
-supporting basic arithmetic. Many operations with two `StaticInt` integers
-will produce another `StaticInt` integer. If one of the arguments to a
-function call isn't static (e.g., `StaticInt(4) + 3`), then the `StaticInt`
-number will promote to a dynamic value.
-
 # List of things to add
 
 - https://github.com/JuliaLang/julia/issues/22216

src/ArrayInterface.jl

@@ -4,6 +4,9 @@ using IfElse
 using Requires
 using LinearAlgebra
 using SparseArrays
+using Static
+using Static: Zero, One, nstatic, _get_tuple, eq, ne, gt, ge, lt, le, eachop, eachop_tuple,
+    find_first_eq, permute, invariant_permutation
 using Base.Cartesian
 
 using Base: @propagate_inbounds, tail, OneTo, LogicalIndex, Slice, ReinterpretArray,
@@ -32,7 +35,11 @@ parameterless_type(x::Type) = __parameterless_type(x)
 const VecAdjTrans{T,V<:AbstractVector{T}} = Union{Transpose{T,V},Adjoint{T,V}}
 const MatAdjTrans{T,M<:AbstractMatrix{T}} = Union{Transpose{T,M},Adjoint{T,M}}
 
-include("static.jl")
+@inline static_length(a::UnitRange{T}) where {T} = last(a) - first(a) + oneunit(T)
+@inline static_length(x) = Static.maybe_static(known_length, length, x)
+@inline static_first(x) = Static.maybe_static(known_first, first, x)
+@inline static_last(x) = Static.maybe_static(known_last, last, x)
+@inline static_step(x) = Static.maybe_static(known_step, step, x)
 
 """
     parent_type(::Type{T})
@@ -51,6 +58,15 @@ parent_type(::Type{Slice{T}}) where {T} = T
 parent_type(::Type{T}) where {T} = T
 parent_type(::Type{R}) where {S,T,A,N,R<:Base.ReinterpretArray{T,N,S,A}} = A
 
+"""
+    has_parent(::Type{T}) -> StaticBool
+
+Returns `True` if `parent_type(T)` a type unique to `T`.
+"""
+has_parent(::Type{T}) where {T} = _has_parent(parent_type(T), T)
+_has_parent(::Type{T}, ::Type{T}) where {T} = False()
+_has_parent(::Type{T1}, ::Type{T2}) where {T1,T2} = True()
+
 """
     known_length(::Type{T})
 
@@ -616,13 +632,8 @@ device(A) = device(typeof(A))
 device(::Type) = nothing
 device(::Type{<:Tuple}) = CPUIndex()
 device(::Type{T}) where {T<:Array} = CPUPointer()
-device(::Type{T}) where {T<:AbstractArray} = CPUIndex()
-device(::Type{T}) where {T<:PermutedDimsArray} = device(parent_type(T))
-device(::Type{T}) where {T<:Transpose} = device(parent_type(T))
-device(::Type{T}) where {T<:Adjoint} = device(parent_type(T))
-device(::Type{T}) where {T<:ReinterpretArray} = device(parent_type(T))
-device(::Type{T}) where {T<:ReshapedArray} = device(parent_type(T))
-function device(::Type{T}) where {T<:SubArray}
+device(::Type{T}) where {T<:AbstractArray} = _device(has_parent(T), T)
+function _device(::True, ::Type{T}) where {T}
     if defines_strides(T)
         return device(parent_type(T))
     else
@@ -631,11 +642,14 @@ function device(::Type{T}) where {T<:SubArray}
 end
 _not_pointer(::CPUPointer) = CPUIndex()
 _not_pointer(x) = x
+_device(::False, ::Type{T}) where {T<:DenseArray} = CPUPointer()
+_device(::False, ::Type{T}) where {T} = CPUIndex()
 
 """
     defines_strides(::Type{T}) -> Bool
 
-Is strides(::T) defined?
+Is strides(::T) defined? It is assumed that types returning `true` also return a valid
+pointer on `pointer(::T)`.
 """
 defines_strides(x) = defines_strides(typeof(x))
 function defines_strides(::Type{T}) where {T}
@@ -787,9 +801,20 @@ Base.size(A::AbstractArray2, dim) = Int(ArrayInterface.size(A, dim))
 Base.axes(A::AbstractArray2) = ArrayInterface.axes(A)
 Base.axes(A::AbstractArray2, dim) = ArrayInterface.axes(A, dim)
 
-Base.strides(A::AbstractArray2) = map(Int, ArrayInterface.strides(A))
+function Base.strides(A::AbstractArray2)
+    defines_strides(A) || throw(MethodError(Base.strides, (A,)))
+    return map(Int, ArrayInterface.strides(A))
+end
 Base.strides(A::AbstractArray2, dim) = Int(ArrayInterface.strides(A, dim))
 
+function Base.IndexStyle(::Type{T}) where {T<:AbstractArray2}
+    if parent_type(T) <: T
+        return IndexCartesian()
+    else
+        return IndexStyle(parent_type(T))
+    end
+end
+
 function Base.length(A::AbstractArray2)
     len = known_length(A)
     if len === nothing

src/axes.jl

@@ -35,14 +35,16 @@ function axes_types(::Type{T}) where {T}
         return axes_types(parent_type(T))
     end
 end
+axes_types(::Type{LinearIndices{N,R}}) where {N,R} = R
+axes_types(::Type{CartesianIndices{N,R}}) where {N,R} = R
 function axes_types(::Type{T}) where {T<:VecAdjTrans}
     return Tuple{OptionallyStaticUnitRange{One,One},axes_types(parent_type(T), One())}
 end
 function axes_types(::Type{T}) where {T<:MatAdjTrans}
-    return eachop_tuple(_get_tuple, axes_types(parent_type(T)), to_parent_dims(T))
+    return eachop_tuple(_get_tuple, axes_types(parent_type(T)); iterator=to_parent_dims(T))
 end
 function axes_types(::Type{T}) where {T<:PermutedDimsArray}
-    return eachop_tuple(_get_tuple, axes_types(parent_type(T)), to_parent_dims(T))
+    return eachop_tuple(_get_tuple, axes_types(parent_type(T)); iterator=to_parent_dims(T))
 end
 function axes_types(::Type{T}) where {T<:AbstractRange}
     if known_length(T) === nothing
@@ -59,7 +61,7 @@ _int_or_static_int(::Nothing) = Int
 _int_or_static_int(x::Int) = StaticInt{x}
 
 @inline function axes_types(::Type{T}) where {N,P,I,T<:SubArray{<:Any,N,P,I}}
-    return eachop_tuple(_sub_axis_type, T, to_parent_dims(T))
+    return eachop_tuple(_sub_axis_type, T; iterator=to_parent_dims(T))
 end
 @inline function _sub_axis_type(::Type{A}, dim::StaticInt) where {T,N,P,I,A<:SubArray{T,N,P,I}}
     return OptionallyStaticUnitRange{
@@ -73,12 +75,12 @@ function axes_types(::Type{R}) where {T,N,S,A,R<:ReinterpretArray{T,N,S,A}}
         if sizeof(S) === sizeof(T)
             return axes_types(A)
         elseif sizeof(S) > sizeof(T)
-            return eachop_tuple(_reshaped_axis_type, R, to_parent_dims(R))
+            return eachop_tuple(_reshaped_axis_type, R; iterator=to_parent_dims(R))
         else
-            return eachop_tuple(axes_types, A, to_parent_dims(R))
+            return eachop_tuple(axes_types, A; iterator=to_parent_dims(R))
         end
     else
-        return eachop_tuple(_non_reshaped_axis_type, R, to_parent_dims(R))
+        return eachop_tuple(_non_reshaped_axis_type, R; iterator=to_parent_dims(R))
     end
 end
 

src/dimensions.jl

@@ -182,12 +182,12 @@ end
         if invariant_permutation(perm, perm) isa True
             return dimnames(parent_type(T))
         else
-            return eachop(dimnames, parent_type(T), perm)
+            return eachop(dimnames, parent_type(T); iterator=perm)
         end
     end
 end
 function dimnames(::Type{T}) where {T<:SubArray}
-    return eachop(dimnames, parent_type(T), to_parent_dims(T))
+    return eachop(dimnames, parent_type(T); iterator=to_parent_dims(T))
 end
 
 _to_int(x::Integer) = Int(x)
@@ -241,7 +241,7 @@ end
     inds::Tuple
 ) where {N}
 
-    out = eachop(((x, nd, inds), i) -> order_named_inds(x, nd, inds, i), (x, nd, inds), nstatic(Val(N)))
+    out = eachop(order_named_inds, x, nd, inds; iterator=nstatic(Val(N)))
     _order_named_inds_check(out, length(nd))
     return out
 end

src/indexing.jl

@@ -31,7 +31,7 @@ argdims(::ArrayStyle, ::Type{T}) where {N,T<:AbstractArray{<:Any,N}} = N
 argdims(::ArrayStyle, ::Type{T}) where {N,T<:LogicalIndex{<:Any,<:AbstractArray{Bool,N}}} = N
 _argdims(s::ArrayStyle, ::Type{I}, i::StaticInt) where {I} = argdims(s, _get_tuple(I, i))
 function argdims(s::ArrayStyle, ::Type{T}) where {N,T<:Tuple{Vararg{Any,N}}}
-    return eachop(_argdims, s, T, nstatic(Val(N)))
+    return eachop(_argdims, s, T; iterator=nstatic(Val(N)))
 end
 
 """
@@ -183,7 +183,7 @@ can_flatten(::Type{A}, ::Type{T}) where {A,T<:CartesianIndices} = true
 can_flatten(::Type{A}, ::Type{T}) where {A,N,T<:AbstractArray{Bool,N}} = N > 1
 can_flatten(::Type{A}, ::Type{T}) where {A,N,T<:CartesianIndex{N}} = true
 function can_flatten(::Type{A}, ::Type{T}) where {A,N,T<:Tuple{Vararg{Any,N}}}
-    return any(eachop(_can_flat, A, T, nstatic(Val(N))))
+    return any(eachop(_can_flat, A, T; iterator=nstatic(Val(N))))
 end
 function _can_flat(::Type{A}, ::Type{T}, i::StaticInt) where {A,T}
     if can_flatten(A, _get_tuple(T, i)) === true

src/size.jl

@@ -22,7 +22,7 @@ function size(a::A) where {A}
 end
 #size(a::AbstractVector) = (size(a, One()),)
 
-size(x::SubArray) = eachop(_sub_size, x.indices, to_parent_dims(x))
+size(x::SubArray) = eachop(_sub_size, x.indices; iterator=to_parent_dims(x))
 _sub_size(x::Tuple, ::StaticInt{dim}) where {dim} = static_length(getfield(x, dim))
 
 @inline size(B::VecAdjTrans) = (One(), length(parent(B)))
@@ -81,7 +81,7 @@ Returns the size of each dimension for `T` known at compile time. If a dimension
 have a known size along a dimension then `nothing` is returned in its position.
 """
 known_size(x) = known_size(typeof(x))
-known_size(::Type{T}) where {T} = eachop(known_size, T, nstatic(Val(ndims(T))))
+known_size(::Type{T}) where {T} = eachop(known_size, T; iterator=nstatic(Val(ndims(T))))
 
 """
     known_size(::Type{T}, dim)