This completely fails

[virzak]

[CreateSyncVersion]
public static async IAsyncEnumerable<(T1?, T2?)> MergeDisjoint<T1, T2>(
    IAsyncEnumerable<T1> first,
    IAsyncEnumerable<T2> second,
    CancellationToken ct = default)
{
    var e1 = first.GetAsyncEnumerator(ct);
    var e2 = second.GetAsyncEnumerator(ct);

    try
    {
        var move1 = e1.MoveNextAsync();
        var move2 = e2.MoveNextAsync();

        while (true)
        {
            var task = await Task.WhenAny(move1.AsTask(), move2.AsTask());

            if (task == move1.AsTask())
            {
                if (move1.Result)
                {
                    yield return (e1.Current, default);
                    move1 = e1.MoveNextAsync();
                }
                else
                {
                    move1 = default;
                    break;
                }
            }
            else if (task == move2.AsTask())
            {
                if (move2.Result)
                {
                    yield return (default, e2.Current);
                    move2 = e2.MoveNextAsync();
                }
                else
                {
                    move2 = default;
                    break;
                }
            }
        }

        // Drain the remaining one
        if (move1.IsCompletedSuccessfully && move1.Result)
        {
            do
            {
                yield return (e1.Current, default);
            } while (await e1.MoveNextAsync());
        }

        if (move2.IsCompletedSuccessfully && move2.Result)
        {
            do
            {
                yield return (default, e2.Current);
            } while (await e2.MoveNextAsync());
        }
    }
    finally
    {
        await e1.DisposeAsync();
        await e2.DisposeAsync();
    }
}

[fubar-coder]

TBH, this is something where I would expect that this library/tool cannot automatically create a sync version.

[virzak]

You may be right. I don't even remember where I got this source from. Might have been ai generated.

[fubar-coder]

When translated to "Reactive Extensions", it'd look like the following:

Observable<T1> first;
Observable<T2> second;

var result = first.Select(x => (x, default(T2))).Merge(second.Select(x => (default(T1), x)));