LazyStack.lazystack

Author: mcabbott

src/stack.jl

@@ -1,5 +1,5 @@
 
-import LazyStack
+using LazyStack
 
 # for stack_iter
 LazyStack.no_wraps(a::KeyedArray) = LazyStack.no_wraps(NamedDims.unname(parent(a)))
@@ -14,35 +14,35 @@ function LazyStack.rewrap_like(A, a::NamedTuple)
 end
 
 # tuple of arrays
-function LazyStack.stack(x::Tuple{Vararg{<:KeyedArray}})
+function LazyStack.lazystack(x::Tuple{Vararg{<:KeyedArray}})
     KeyedArray(LazyStack.stack(map(parent, x)), stack_keys(x))
 end
 
 stack_keys(xs::Tuple{Vararg{<:KeyedArray}}) =
     (keys_or_axes(first(xs))..., Base.OneTo(length(xs)))
 
 # array of arrays: first strip off outer containers...
-function LazyStack.stack(xs::KeyedArray{<:AbstractArray})
+function LazyStack.lazystack(xs::KeyedArray{<:AbstractArray})
     KeyedArray(LazyStack.stack(parent(xs)), stack_keys(xs))
 end
-function LazyStack.stack(xs::KeyedArray{<:AbstractArray,N,<:NamedDimsArray{L}}) where {L,N}
+function LazyStack.lazystack(xs::KeyedArray{<:AbstractArray,N,<:NamedDimsArray{L}}) where {L,N}
     data = LazyStack.stack(parent(parent(xs)))
     KeyedArray(LazyStack.ensure_named(data, LazyStack.getnames(xs)), stack_keys(xs))
 end
-function LazyStack.stack(xs::NamedDimsArray{L,<:AbstractArray,N,<:KeyedArray}) where {L,N}
+function LazyStack.lazystack(xs::NamedDimsArray{L,<:AbstractArray,N,<:KeyedArray}) where {L,N}
     data = LazyStack.stack(parent(parent(xs)))
     LazyStack.ensure_named(KeyedArray(data, stack_keys(xs)), LazyStack.getnames(xs))
 end
 
 # ... then deal with inner ones:
-function LazyStack.stack(x::AT) where {AT <: AbstractArray{<:KeyedArray{T,IN},ON}} where {T,IN,ON}
+function LazyStack.lazystack(x::AT) where {AT <: AbstractArray{<:KeyedArray{T,IN},ON}} where {T,IN,ON}
     KeyedArray(LazyStack.Stacked{T, IN+ON, AT}(x), stack_keys(x))
 end
-function LazyStack.stack(x::AT) where {AT <: AbstractArray{<:KeyedArray{T,IN,IT},ON}} where {IT<:NamedDimsArray} where {T,IN,ON}
+function LazyStack.lazystack(x::AT) where {AT <: AbstractArray{<:KeyedArray{T,IN,IT},ON}} where {IT<:NamedDimsArray} where {T,IN,ON}
     data = LazyStack.Stacked{T, IN+ON, AT}(x)
     KeyedArray(NamedDimsArray(data, LazyStack.getnames(x)), stack_keys(x))
 end
-function LazyStack.stack(x::AT) where {AT <: AbstractArray{<:NamedDimsArray{L,T,IN,IT},ON}} where {IT<:KeyedArray} where {T,IN,ON,L}
+function LazyStack.lazystack(x::AT) where {AT <: AbstractArray{<:NamedDimsArray{L,T,IN,IT},ON}} where {IT<:KeyedArray} where {T,IN,ON,L}
     data = LazyStack.Stacked{T, IN+ON, AT}(x)
     NamedDimsArray(KeyedArray(data, stack_keys(x)), LazyStack.getnames(x))
 end