rm docstrings

Author: mcabbott

src/Compat.jl

@@ -366,127 +366,9 @@ end
 if VERSION < v"1.9.0-DEV.1163"
     import Base: IteratorSize, HasLength, HasShape, OneTo
     export stack
-    
-    """
-        stack(iter; [dims])
-
-    Combine a collection of arrays (or other iterable objects) of equal size
-    into one larger array, by arranging them along one or more new dimensions.
-
-    By default the axes of the elements are placed first,
-    giving `size(result) = (size(first(iter))..., size(iter)...)`.
-    This has the same order of elements as [`Iterators.flatten`](@ref)`(iter)`.
-
-    With keyword `dims::Integer`, instead the `i`th element of `iter` becomes the slice
-    [`selectdim`](@ref)`(result, dims, i)`, so that `size(result, dims) == length(iter)`.
-    In this case `stack` reverses the action of [`eachslice`](@ref) with the same `dims`.
-
-    The various [`cat`](@ref) functions also combine arrays. However, these all
-    extend the arrays' existing (possibly trivial) dimensions, rather than placing
-    the arrays along new dimensions.
-    They also accept arrays as separate arguments, rather than a single collection.
-
-    !!! compat "Julia 1.9"
-        This function requires at least Julia 1.9.
-
-    # Examples
-    ```jldoctest
-    julia> vecs = (1:2, [30, 40], Float32[500, 600]);
-
-    julia> mat = stack(vecs)
-    2×3 Matrix{Float32}:
-     1.0  30.0  500.0
-     2.0  40.0  600.0
-
-    julia> mat == hcat(vecs...) == reduce(hcat, collect(vecs))
-    true
-
-    julia> vec(mat) == vcat(vecs...) == reduce(vcat, collect(vecs))
-    true
-
-    julia> stack(zip(1:4, 10:99))  # accepts any iterators of iterators
-    2×4 Matrix{Int64}:
-      1   2   3   4
-     10  11  12  13
-
-    julia> vec(ans) == collect(Iterators.flatten(zip(1:4, 10:99)))
-    true
-
-    julia> stack(vecs; dims=1)  # unlike any cat function, 1st axis of vecs[1] is 2nd axis of result
-    3×2 Matrix{Float32}:
-       1.0    2.0
-      30.0   40.0
-     500.0  600.0
-
-    julia> x = rand(3,4);
-
-    julia> x == stack(eachcol(x)) == stack(eachrow(x), dims=1)  # inverse of eachslice
-    true
-    ```
-
-    Higher-dimensional examples:
-
-    ```jldoctest
-    julia> A = rand(5, 7, 11);
 
-    julia> E = eachslice(A, dims=2);  # a vector of matrices
-
-    julia> (element = size(first(E)), container = size(E))
-    (element = (5, 11), container = (7,))
-
-    julia> stack(E) |> size
-    (5, 11, 7)
-
-    julia> stack(E) == stack(E; dims=3) == cat(E...; dims=3)
-    true
-
-    julia> A == stack(E; dims=2)
-    true
-
-    julia> M = (fill(10i+j, 2, 3) for i in 1:5, j in 1:7);
-
-    julia> (element = size(first(M)), container = size(M))
-    (element = (2, 3), container = (5, 7))
-
-    julia> stack(M) |> size  # keeps all dimensions
-    (2, 3, 5, 7)
-
-    julia> stack(M; dims=1) |> size  # vec(container) along dims=1
-    (35, 2, 3)
-
-    julia> hvcat(5, M...) |> size  # hvcat puts matrices next to each other
-    (14, 15)
-    ```
-    """
     stack(iter; dims=:) = _stack(dims, iter)
 
-    """
-        stack(f, args...; [dims])
-
-    Apply a function to each element of a collection, and `stack` the result.
-    Or to several collections, [`zip`](@ref)ped together.
-
-    The function should return arrays (or tuples, or other iterators) all of the same size.
-    These become slices of the result, each separated along `dims` (if given) or by default
-    along the last dimensions.
-
-    See also [`mapslices`](@ref), [`eachcol`](@ref).
-
-    # Examples
-    ```jldoctest
-    julia> stack(c -> (c, c-32), "julia")
-    2×5 Matrix{Char}:
-     'j'  'u'  'l'  'i'  'a'
-     'J'  'U'  'L'  'I'  'A'
-
-    julia> stack(eachrow([1 2 3; 4 5 6]), (10, 100); dims=1) do row, n
-             vcat(row, row .* n, row ./ n)
-           end
-    2×9 Matrix{Float64}:
-     1.0  2.0  3.0   10.0   20.0   30.0  0.1   0.2   0.3
-     4.0  5.0  6.0  400.0  500.0  600.0  0.04  0.05  0.06
-    ```
-    """
     stack(f, iter; dims=:) = _stack(dims, f(x) for x in iter)
     stack(f, xs, yzs...; dims=:) = _stack(dims, f(xy...) for xy in zip(xs, yzs...))