[API Proposal]: params ReadOnlySpan<T> overloads for existing params T[] overloads #77873

namespace System
{
    public static class MemoryExtensions
    {
        public static bool TryWrite(this Span<char> destination, IFormatProvider? provider, CompositeFormat format, out int charsWritten, **params** ReadOnlySpan<object?> args);
    }
    public class String
    {
        public static string Format(IFormatProvider? provider, CompositeFormat format, **params** ReadOnlySpan<object?> args);
    }
}
namespace System.Collections.Generic
{
    public static class CollectionExtensions
    {
        public static void AddRange<T>(this List<T> list, **params** ReadOnlySpan<T> source);
        public static void InsertRange<T>(this List<T> list, int index, **params** ReadOnlySpan<T> source);
    }
}
namespace System.Collections.Immutable
{
    public static class ImmutableArray
    {
        public static ImmutableArray<T> Create<T>(**params** ReadOnlySpan<T> items);
    }
    public struct ImmutableArray<T>
    {
        public ImmutableArray<T> AddRange(**params** ReadOnlySpan<T> items);
        public ImmutableArray<T> InsertRange(int index, **params** ReadOnlySpan<T> items);

        public sealed class Builder
        {
            public void AddRange(**params** ReadOnlySpan<T> items);
            public void AddRange<TDerived>(**params** ReadOnlySpan<TDerived> items) where TDerived : T;
        }
    }
    public static class ImmutableHashSet
    {
        public static ImmutableHashSet<T> Create<T>(**params** ReadOnlySpan<T> items);
        public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T>? equalityComparer, **params** ReadOnlySpan<T> items);
    }
    public static class ImmutableList
    {
        public static ImmutableList<T> Create<T>(**params** ReadOnlySpan<T> items);
    }
    public static class ImmutableQueue
    {
        public static ImmutableQueue<T> Create<T>(**params** ReadOnlySpan<T> items);
    }
    public static class ImmutableSortedSet
    {
        public static ImmutableSortedSet<T> Create<T>(**params** ReadOnlySpan<T> items);
        public static ImmutableSortedSet<T> Create<T>(IComparer<T>? comparer, **params** ReadOnlySpan<T> items)
    }
    public static class ImmutableStack
    {
        public static ImmutableStack<T> Create<T>(**params** ReadOnlySpan<T> items);
    }
}
namespace System.Diagnostics.Metrics
{
    public sealed class Counter<T> : Instrument<T> where T : struct
    {
        public void Add(T delta, **params** ReadOnlySpan<KeyValuePair<string, object?>> tags);
    }
    public sealed class Histogram<T> : Instrument<T> where T : struct
    {
        public void Record(T value, **params** ReadOnlySpan<KeyValuePair<string, object?>> tags);
    }
    public readonly struct Measurement<T> where T : struct
    {
        public Measurement(T value, **params** ReadOnlySpan<KeyValuePair<string, object?>> tags);
    }
    public struct TagList : IList<KeyValuePair<string, object?>>, IReadOnlyList<KeyValuePair<string, object?>>
    {
        public TagList(**params** ReadOnlySpan<KeyValuePair<string, object?>> tagList);
    }
    public sealed class UpDownCounter<T> : Instrument<T> where T : struct
    {
        public void Add(T delta, **params** ReadOnlySpan<KeyValuePair<string, object?>> tags);
    }
}
namespace System.Text
{
    public sealed class StringBuilder
    {
        public StringBuilder AppendFormat(IFormatProvider? provider, CompositeFormat format, **params** ReadOnlySpan<object?> args);
    }
}

namespace System
{
    public static class Console
    {
        public static void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
        public static void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
    }
    public abstract class Delegate
    {
        public static Delegate? Combine(params ReadOnlySpan<Delegate?> delegates);
    }
    public class String
    {
        public static string Concat(params ReadOnlySpan<object?> args);
        public static string Concat(params ReadOnlySpan<string?> values);
        public static string Format([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> args);
        public static string Format(IFormatProvider? provider, [StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> args);
        public static string Join(char separator, params ReadOnlySpan<string?> value);
        public static string Join(string? separator, params ReadOnlySpan<string?> value);
        public static string Join(char separator, params ReadOnlySpan<object?> values);
        public static string Join(string? separator, params ReadOnlySpan<object?> values);
        public string[] Split(params ReadOnlySpan<char> separator);
        public unsafe string Trim(params ReadOnlySpan<char> trimChars);
        public unsafe string TrimStart(params ReadOnlySpan<char> trimChars);
        public unsafe string TrimEnd(params ReadOnlySpan<char> trimChars);
    }
}
namespace System.CodeDom.Compiler
{
    public class IndentedTextWriter : TextWriter
    {
        public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
        public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
    }
}
namespace System.IO
{
    public static class Path
    {
        public static string Combine(params ReadOnlySpan<string> paths);
        public static string Join(params ReadOnlySpan<string?> paths);
    }
    public class StreamWriter : TextWriter
    {
        public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
        public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
    }
    public abstract class TextWriter
    {
        public virtual void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
        public virtual void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> arg);
    }
}
namespace System.Text
{
    public class StringBuilder
    {
        public StringBuilder AppendJoin(string? separator, params ReadOnlySpan<object?> values);
        public StringBuilder AppendJoin(string? separator, params ReadOnlySpan<string?> values);
        public StringBuilder AppendJoin(char separator, params ReadOnlySpan<object?> values);
        public StringBuilder AppendJoin(char separator, params ReadOnlySpan<string?> values);
        public StringBuilder AppendFormat([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> args);
        public StringBuilder AppendFormat(IFormatProvider? provider, [StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params ReadOnlySpan<object?> args);
    }
}
namespace System.Text.Json.Nodes
{
    public sealed class JsonArray
    {
        public JsonArray(params ReadOnlySpan<JsonNode?> items);
        public JsonArray(JsonNodeOptions options, params ReadOnlySpan<JsonNode?> items);
    }
}
namespace System.Text.Json.Serialization.Metadata
{
        public static IJsonTypeInfoResolver Combine(params ReadOnlySpan<IJsonTypeInfoResolver?> resolvers);
}
namespace System.Threading
{
    public class CancellationTokenSource
    {
        public static CancellationTokenSource CreateLinkedTokenSource(params ReadOnlySpan<CancellationToken> tokens);
    }
    public class Task
    {
        public static void WaitAll(params ReadOnlySpan<Task> tasks);
        public static Task WhenAll(params ReadOnlySpan<Task> tasks);
        public static Task<TResult[]> WhenAll<TResult>(params ReadOnlySpan<Task<TResult>> tasks);
        public static Task<Task> WhenAny(params ReadOnlySpan<Task> tasks);
        public static Task<Task<TResult>> WhenAny<TResult>(params ReadOnlySpan<Task<TResult>> tasks);
    }
}