My resolution was to treat "create" as an imperative operation specific to imperative data structures (since it implies something about identity). Hence only have it on Array. And use "replicate" for the functional operation.

Thoughts?

But the operations are exactly the same. Why is one deemed "procedural" and the other "functional"? The only difference is the name, and surely the name given does not affect the inherent functional-ness or procedural-ness of the operation.

For me replicate means to create a copy of the same thing, i.e. list.
create is probably better than replicate.

Maybe an other name?
I would prefer repeat with signature 'T -> int -> C<'T> or is it another addition candidate?

[ Edited after, cc @forki ]

Yes. And both String.replicate and List.replicate already exists. So today we have the irregular:

String.replicate: int -> string -> string
List.replicate: int -> 'T -> list<'T>
Array.create: int -> 'T -> 'T[]

One way to normalize would be

create: int -> X -> C<X>   // for String, Array, List, Seq
repeat: int -> C<X> -> C<X>   // for String, Array, List, Seq

with these additional ones for Seq:

createInfinite: 'T -> C<X>   // for Seq
repeatInfinite: C<X> -> C<X>   // for Seq

Seq.repeatInfinite is sometimes called Seq.cycle, which is a nice name. However the more regular names above appear wise, to align with Seq.init, Seq.initInfinite etc.

Note, I'm not super happy about the name repeat here.

Cheers
Don