J>var _1 = 
J>    from _2 in DoBlaBlaAsync()
J>    from _3 in DoOtherBlaBlaAsync()
J>    from x in GetBlaBlaAsync()
J>    from _4 in DoWorkAsync(x)
J>    select 1;
J>

class Program {
    static void Main(string[] args) {
        AppInstance.Get().DoMain(IOMain);
    }
    static IO<None> IOMain() {
        return
            from _ in IO.Do(() => Console.WriteLine("What is your name?"))
            from name in IO.Do(() => Console.ReadLine())
            let message = "Hi, " + name + "!"
            from r in IO.Do(() => Console.WriteLine(message))
            select r;
    }
}

var cities = new[]
{
    (name:"NYC",    streets: new[] { "1", "2", "3" }),
    (name:"Moscow", streets: new[] { "3", "5", "8" }),
};

var q =
    from c in cities
    from s in c.streets
    select c.name + " " + s;

foreach (var item in q)
{
    Console.WriteLine(item);
}

public static IEnumerable<TResult> SelectMany<TSource,TResult>(
    this IEnumerable<TSource> source,
    Func<TSource, IEnumerable<TResult>> selector)

abstract class Maybe<T>
{
    public class Nothing : Maybe<T> {}
    public class Just : Maybe<T>
    {
        public T Value;
    }
}

// return
public static Maybe<T> ToMaybe<T>(this T value)
{
    return value == null ? (Maybe<T>)new Maybe<T>.Nothing() : new Maybe<T>.Just { Value = value };
}

// bind
public static Maybe<T2> SelectMany<T1,T2>(
    this Maybe<T1> source, Func<T1,Maybe<T2>> selector)
{
    if (source is Maybe<T1>.Just j) return selector(j.Value);
    return new Maybe<T2>.Nothing();
}

// специфика linq - типовой метод для всех монад
public static Maybe<T3> SelectMany<T1,T2,T3>(
    this Maybe<T1> source, Func<T1,Maybe<T2>> collectionSelector, Func<T1,T2,T3> resultSelector)
{
    return source.SelectMany(x => collectionSelector(x).SelectMany(y => resultSelector(x, y).ToMaybe()));
}

var n =
    from c in 1.ToMaybe()
    from s in "2".ToMaybe()
    from x in 2.ToMaybe()
    select s + c + x;

Console.WriteLine(n);

// bind
public static Task<T2> SelectMany<T1,T2>(
    this Task<T1> source, Func<T1,Task<T2>> selector)
{
    return source.ContinueWith(x => selector(x.Result)).Unwrap();
}

// вспомогательный метод, почти тоже самое что было в Maybe.
public static Task<T3> SelectMany<T1,T2,T3>(
    this Task<T1> source, Func<T1,Task<T2>> collectionSelector, Func<T1,T2,T3> resultSelector)
{
    return source.SelectMany(x => collectionSelector(x).SelectMany(y => resultSelector(x, y).ToTask()));
}

var t =
    from c in Task.FromResult(1)
    from s in Task.Run(() => "7" + c)
    select s + c;

Console.WriteLine(t.Result);