someObservable.Select(x => getY(x));

Y getY(X x)
{
  if (x.Value == X.ABC)
    return new Y(1);
  else
    return new Y(2);
}

Y getY(X x)
{
  if (x.Value == X.ABC)
    return new Y(1);
  else
  if (x.SomethingElse == true)
  {
     Thread.Sleep(timeout);
     if (x.Value == X.ABC)
       return new Y(1);
     else
       return new Y(2);
  }
}

IObservable<Y> getY(X x)
{
  if (x.Value == X.ABC)
    return Observable.Return(new Y(1));
  else
  if (x.SomethingElse == true)
  {
     return Observable.Delay(Observable.Return(x), timeout).Select(xx => xx.Value == X.ABC ? new Y(1) : new Y(2));
  }
}

IObservable<Y> getY(X x)
{
  return Observable.Create<Y>(async (obs, token) =>
  {
    if (x.Value == X.ABC) {
        obs.OnNext(new Y(1));
    }
    else
    if (x.SomethingElse == true)
    {
        await Task.Delay(timeout, token);
        if (x.Value == X.ABC) {
           obs.OnNext(new Y(1));
        }
        else {
           obs.OnNext(new Y(2));
        }
     }
   }

TK>IObservable<Y> getY(X x)
TK>{
TK>  if (x.Value == X.ABC)
TK>    return Observable.Return(new Y(1));
TK>  else
TK>  if (x.SomethingElse == true)
TK>  {
TK>     return Observable.Delay(Observable.Return(x), timeout).Select(xx => xx.Value == X.ABC ? new Y(1) : new Y(2));
TK>  }
TK>}
TK>

TK>IObservable<Y> getY(X x)
TK>{
TK>  return Observable.Create<Y>(async (obs, token) =>
TK>  {
TK>    if (x.Value == X.ABC) {
TK>        obs.OnNext(new Y(1));
TK>    }
TK>    else
TK>    if (x.SomethingElse == true)
TK>    {
TK>        await Task.Delay(timeout, token);
TK>        if (x.Value == X.ABC) {
TK>           obs.OnNext(new Y(1));
TK>        }
TK>        else {
TK>           obs.OnNext(new Y(2));
TK>        }
TK>     }
TK>   }
TK>

someObservable
  .Select(x => getY(x))
  .Where(y => y.IsValid)
  .Scan(new { Current=abc, Prev=null }, (prev, cur) => new { Current=cur, Prev=prev.Current })
  .Select(makeResult)

someObservable
  .Select(x => getY(x))
  .Merge()|Concat()|MergeAndSort()
  .Where(y => y.IsValid)
  .Scan(new { Current=abc, Prev=null }, (prev, cur) => new { Current=cur, Prev=prev.Current })
  .Select(makeResult)

using System;
using System.Reactive.Linq;

namespace RxTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var r = Observable.Range(0, 10);

            r.Select(x => x)
                .Select(x => getY(x))
                .Concat()
                .Subscribe(x => Console.WriteLine("a: " + x));
            

            Console.ReadKey();
        }

        private static IObservable<int> getY(int i, int tries = 0)
        {
            Console.WriteLine("In getY: i = {0}, tries = {1}", i, tries);

            if (i > 5)
            {
                int y;
                if (tryGetReal(i, out y))
                {
                    // No delay
                    return Observable.Return(y);
                }
                else
                {
                    if (tries < 3)
                    {
                        // Let's Try again
                        return Observable.Defer(() => getY(i, tries + 1)).Delay(TimeSpan.FromMilliseconds(100));
                    }
                    else
                    {
                        // No more tries, stop !
                        return Observable.Empty<int>();
                    }
                }
            }
            else
            {
                return Observable.Empty<int>();
            }
        }

        private static bool tryGetReal(int i, out int y)
        {
            if (i > 7)
            {
                y = i;
                return false;
            }
            else
            {
                y = i;
                return true;
            }
        }
    }
}

var query = from counter in Observable.Timer(TimeSpan.FromMsec(0), TimeSpan.FromMsec(100)).Take(repeatCount)
  let result = tryGetReal(x)
  where result.Success
  select result.Value;
return query.Take(1);

async Task RunProcessing<T>(IObservable<T> source)
{
     foreach (var sample in source.AsEnumerable())
     {
        var output = await ProcessItem(sample);
        Console.WriteLine("a: " + output);
     }
}