Implement accumulate and friends for Tuple

[tkf]

close #26690

Demo:

julia> demo() = cumprod((1, 2, 3))
demo (generic function with 1 method)

julia> @code_typed optimize=true demo()
CodeInfo(
1 ─     return (1, 2, 6)
) => Tuple{Int64,Int64,Int64}

[tkf]

Note: this uses the machinery I added in #33526

julia/base/reduce.jl

Lines 73 to 78 in 3720edf

	struct BottomRF{T}
	rf::T
	end
	@inline (op::BottomRF)(::_InitialValue, x) = reduce_first(op.rf, x)
	@inline (op::BottomRF)(acc, x) = op.rf(acc, x)

[stevengj]

Does this implementation lead to unrolled code?

[tkf]

It const-folds, as shown in the OP. It is also unrolled when the tuple is not constant:

julia> @code_typed optimize=true cumsum(ntuple(identity, 10))
CodeInfo(
1 ── %1  = (getfield)(itr, 1)::Int64
│    %2  = (getfield)(itr, 2)::Int64
│    %3  = (getfield)(itr, 3)::Int64
│    %4  = (getfield)(itr, 4)::Int64
│    %5  = (getfield)(itr, 5)::Int64
│    %6  = (getfield)(itr, 6)::Int64
│    %7  = (getfield)(itr, 7)::Int64
│    %8  = (getfield)(itr, 8)::Int64
│    %9  = (getfield)(itr, 9)::Int64
│    %10 = (getfield)(itr, 10)::Int64
│    %11 = Base.add_int(%1, %2)::Int64
│    %12 = Base.add_int(%11, %3)::Int64
│    %13 = Base.add_int(%12, %4)::Int64
│    %14 = Base.add_int(%13, %5)::Int64
│    %15 = Base.add_int(%14, %6)::Int64
│    %16 = Base.add_int(%15, %7)::Int64
│    %17 = Base.add_int(%16, %8)::Int64
│    %18 = Base.add_int(%17, %9)::Int64
│    %19 = Base.add_int(%18, %10)::Int64
│    %20 = Core.tuple(%1, %11, %12, %13, %14, %15, %16, %17, %18, %19)::NTuple{10,Int64}
└───       goto #3
2 ──       $(Expr(:meta, :nkw, 1))
3 ┄─       goto #4
4 ──       goto #6
5 ──       $(Expr(:meta, :nkw, 1))
6 ┄─       goto #7
7 ──       goto #9
8 ──       $(Expr(:meta, :nkw, 1))
9 ┄─       goto #10
10 ─       return %20
) => NTuple{10,Int64}

[tkf]

Bump. Can this be merged?