async {
                let request = HttpWebRequest.Create(url)
                let! response = request.AsyncGetResponse()
                use response = response
                let stream = response.GetResponseStream()
                use reader = new StreamReader(stream)
                let! result=  reader.AsyncReadToEnd()
                return (id,result) (* id это id объекта, указывается выше по коду *)
                } 
                |>  Async.Catch
                |>  Async.RunSynchronously
                |>  function
                    | Choice1Of2 (id2,result2)     -> (id2,result2)
                    | Choice2Of2 (ex : exn) -> (id,ex.Message)

let ids = [1;2;3;4]
let results = ids 
|> List.map (fun id -> async {
...
})
|> List.map Async.Catch
|> Async.Parallel 
|> Async.RunSynchronously
|> List.ofArray
 
let errors = results |> List.choose (function
                                     | Choice2Of2 e -> Some e
                                     | _ -> None results)

    [TestCaseAttribute(<#
Value(20)
Value(20)
Value(20)
Value(121)
Value(121 20)
Value(20 123)
Value(20 20)
#>)]
    public static Test1(stream : IO.TextWriter) : void
    {
      def fn(n)
      {
        comp async
        {
          if (n < 20)
            returncomp fn(n + 1);
          else
            return n;
        }
      }
      def f(n1, n2)
      {
        comp async
        {
          defcomp n1 = fn(n1);
          defcomp n2 = fn(n2);
          return $"$n1 $n2";
        }
      }
      def li = [fn(1), fn(10), fn(15), fn(121)];
      def ls = [f(121, 1), f(11, 123), f(11, 4)];
      def li = li.Map(_.Start());
      def ls = ls.Map(_.Start());
      li.Map(_.GetResult()).Iter(stream.WriteLine(_));
      ls.Map(_.GetResult()).Iter(stream.WriteLine(_));
    }

    private HttpGet(url : string) : Async[string]
    {
      comp async
      {
        def req = WebRequest.Create(url);
        using (defcomp resp = req.AsyncGetResponse())
        using (stream = resp.GetResponseStream())
        using (reader = StreamReader(stream))
          return reader.ReadToEnd();
      }
    }

async {
  try
    ...
    return Choice1Of2 (id, result)
  with
    | exn e -> return Choice2Of2 (id, e)
}

        comp async
        {
          callcomp Async.SwitchTo(poolCtx);
          def fib(n)
          {
            if (n < 2)
              1;
            else
              fib(n - 2) + fib(n - 1);
          }
          def res = fib(cur);

          callcomp Async.SwitchTo(guiCtx);
          textBox1.Text = $"fib($cur) = $res\n" + textBox1.Text;
          progressBar1.Maximum = max;
          progressBar1.Value = cur;
          when (cur < max)
            callcomp proc(cur + 1, max);
        }
      }

WH>        comp async
WH>        {
WH>          callcomp Async.SwitchTo(poolCtx);
WH>          def fib(n)
WH>          {
WH>            if (n < 2)
WH>              1;
WH>            else
WH>              fib(n - 2) + fib(n - 1);
WH>          }
WH>          def res = fib(cur);

WH>          callcomp Async.SwitchTo(guiCtx);
WH>          textBox1.Text = $"fib($cur) = $res\n" + textBox1.Text;
WH>          progressBar1.Maximum = max;
WH>          progressBar1.Value = cur;
WH>          when (cur < max)
WH>            callcomp proc(cur + 1, max);
WH>        }
WH>      }
WH>

open System
open System.Threading

let print fmt = 
    let th = Thread.CurrentThread
    Printf.kprintf (printfn "%O | Id=%d, IsTP=%b, IsBg=%b|%s" DateTime.Now th.ManagedThreadId th.IsThreadPoolThread th.IsBackground) fmt

let workflow = async    {
    print "A"
    do! Async.SwitchToNewThread()
    print "B"
    do! Async.SwitchToThreadPool()
    print "C"
    do! Async.SwitchToContext testSyncContext
    print "D"
    }
Async.StartImmediate workflow
(*
> Async.StartImmediate workflow;;
2/20/2010 9:03:24 PM | Id=1, IsTP=false, IsBg=false|A
2/20/2010 9:03:24 PM | Id=3, IsTP=false, IsBg=true|B // new background thread
2/20/2010 9:03:24 PM | Id=8, IsTP=true, IsBg=true|C // thread from threadpool
2/20/2010 9:03:24 PM | Id=8, IsTP=true, IsBg=true|SynchronizationContext.Post
2/20/2010 9:03:24 PM | Id=8, IsTP=true, IsBg=true|D // post to syncContext
*)

let second f = fun (x, y) -> x, f y
let uncurry f = fun (x, y) -> f x y

let ids = [1..4]
let results =
    ids |>
    List.map (fun id -> id, async { ... }) |>
    List.unzip |>
    (second
        (Async.Catch |> List.map >>
        Async.Parallel >>
        Async.RunSynchronously >>
        List.ofArray)) |>
    (uncurry List.zip) |>
    List.map
        (function
         | id, Choice1Of2 result -> (id, result)
         | id, Choice2Of2 (ex : exn) -> (id, ex.Message))