I like the flexibility of b a lot.

Because this helper will probably be used rarely, I'd even prefer making it more clear with something like updateSlice { start, length } changeSlice

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> updateSlice { start = 2, length = 2 } Array.reverse
--> Array.fromList [ 1, 2, 4, 3, 5 ]

which still doesn't seem overly verbose in my eyes

Also in your first example, are you sure it should be

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> splice 2 0 (Array.singleton 33)
--> Array.fromList [ 1, 2, 33, 4, 5 ]

and not

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> splice 2 0 (Array.singleton 33)
--> Array.fromList [ 1, 2, 33, 3, 4, 5 ]

I like the flexibility of b a lot.

Can you clarify: would you just like to have b or would you like to have both?

Because this helper will probably be used rarely, I'd even prefer making it more clear with something like updateSlice { start, length } changeSlice

My bike shed for this was spliceUpdate. Main reason is that slice takes a pair of indices, splice takes an index and a length. I’m pretty 🤷 on verb-noun order.

We don’t have records like this in the API, but perhaps that’s a shame. Maybe we could even have multiple functions that take/return an {start, length} record.

Also in your first example, are you sure it should be

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> splice 2 0 (Array.singleton 33)
--> Array.fromList [ 1, 2, 33, 4, 5 ]

and not

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> splice 2 0 (Array.singleton 33)
--> Array.fromList [ 1, 2, 33, 3, 4, 5 ]

👍 that’s why doctests are a thing.

Can you clarify: would you just like to have b or would you like to have both?

Good question. I was originally thinking about having only b.
Using (\_ -> new array) for replacing that slice seems quite intuitive.

The only consideration would be that the splice that doesn't take the existing, replaced section is faster since elm isn't a lazy language.

We could of course have an ugly API like

: { start : Int, length : Int } -> ((() -> Array a) -> Array a) -> Array a -> Array a

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> sectionUpdate { start = 2, length = 2 }
        (\section -> Array.reverse (section ()))
--> Array.fromList [ 1, 2, 4, 3, 5 ]

But it's simpler to have one helper for update and one for replace as you described.

slice takes a pair of indices, splice takes an index and a length

I don't hate "splice" as a name for the replace version of this operation; not sure it fits the update one.
We could go for a generic "section" (or "sub") maybe?

I’m pretty 🤷 on verb-noun order.

I agree with your suggestion of putting splice/section/sub/... first :)

Another possible API could be

updateBefore : Int -> (Array a -> Array a) -> Array a -> Array a
updateFrom : Int -> (Array a -> Array a) -> Array a -> Array a

Array.fromList [ 1, 2, 3, 4, 5 ]
    |> updateFrom 2 (updateBefore 2 Array.reverse))
--> Array.fromList [ 1, 2, 4, 3, 5 ]

which is even more versatile/atomic/flexible and possibly more intuitive (since array extra already has slice from a start index and before and end index. splitAt also works quite similar)