anchor.diff:                                  // it will arrive to the results list and stay there
                                   // before the results timeout
                                   let envelope : Envelope<'Task> = inMessage, resultId, [| actor2.Id |]
  -                                actor1.Post(envelope) |> ignore
  +                                do! actor1.Post(envelope) |> Async.Ignore
                                   // do not wait for intermediate result
                                   ()
                               // wait for second actor
  
positive.code:                 result
          //#endregion
  
  //open System
  //open Fredis
  //open Fredis.FSharp
  //open System.Threading
  //open System.Runtime.CompilerServices
  //open System.Runtime.InteropServices
  //open System.Diagnostics
  //
  //
  //
  //[<Extension>]
  //type ActorExtension<'Task, 'TResult> () =
  //    [<Extension>]
  //    static member Start(this : Actor<'Task, 'TResult>) : unit = 
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.Start()
  //    [<Extension>]
  //    static member Stop(this : Actor<'Task, 'TResult>) : unit = 
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.Stop()
  //    [<Extension>]
  //    static member GetTotalCount(this : Actor<'Task, 'TResult>) = 
  //        ActorImpl<'Task, 'TResult>.Counter
  //
  //    [<Extension>]
  //    static member Post<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task) : Guid =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.Post(message)
  //    [<Extension>]
  //    static member PostAsync<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task) : Async<Guid> =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.PostAsync(message)
  //    [<Extension>]
  //    static member TryPost<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task, [<Out>] resultGuid : byref<Guid>) =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.TryPost(message, &resultGuid)
  //    [<Extension>]
  //    static member TryPostAsync<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task) =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.TryPostAsync(message)
  //    
  //    [<Extension>]
  //    static member GetResult(this : Actor<'Task, 'TResult>, resultGuid : Guid) : 'TResult = 
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.GetResult(resultGuid)
  //    [<Extension>]
  //    static member TryGetResult(this : Actor<'Task, 'TResult>, resultGuid : Guid, [<Out>] result : byref<'TResult>) : bool = 
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.TryGetResult(resultGuid, &result)
  //    [<Extension>]
  //    static member GetResultAsync(this : Actor<'Task, 'TResult>, resultGuid : Guid) : Async<'TResult> = 
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.GetResultAsync(resultGuid)
  //    [<Extension>]
  //    static member TryGetResultAsync(this : Actor<'Task, 'TResult>, resultGuid : Guid) : Async<bool*'TResult> = 
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.TryGetResultAsync(resultGuid)
  //
  //    [<Extension>]
  //    static member PostAndGetResult<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task) : 'TResult =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.PostAndGetResult(message)
  //    [<Extension>]
  //    static member PostAndGetResultAsync<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task) : Async<'TResult> =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.PostAndGetResultAsync(message)
  //    [<Extension>]
  //    static member TryPostAndGetResult<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task, [<Out>] result : byref<'TResult>) : bool =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.TryPostAndGetResult(message, &result)
  //    [<Extension>]
  //    static member TryPostAndGetResultAsync<'Task, 'TResult>(this : Actor<'Task, 'TResult>, message : 'Task) : Async<bool*'TResult> =
  //        let actor = ActorImpl<'Task, 'TResult>.Instance(this)
  //        actor.TryPostAndGetResultAsync(message)
  //    
  //    [<Extension>]
  //    //#region This is exact copy of ContinueWith on Fredis.Actor: do not edit this, copy from above
  //    static member ContinueWith<'Task, 'TResult1, 'TResult2>
  //        (this : Actor<'Task, 'TResult1>, 
  //            continuation : Actor<'TResult1, 'TResult2>) : Actor<'Task, 'TResult2> =
  //            let actor1 = ActorImpl<'Task, 'TResult1>.Instance(this)
  //            let actor2 = ActorImpl<'TResult1, 'TResult2>.Instance(continuation)
  //            let computation : Message<'Task> * string -> Async<Message<'TResult2>> = 
  //                fun (inMessage, resultId) -> 
  //                    async {
  //                        // 1. check if we have the final result. that could *very rarely* happen if 
  //                        // we resume work from dead continuator while actor1 and actor2 are alive
  //                        // (it takes a local cache lookup - very cheap)
  //                        let secondIsDone, r2 = actor2.TryGetResultIfItDefinitelyExists(resultId)
  //                        if secondIsDone then // extremely unusual
  //                            return r2
  //                        else
  //                            // 2. check if we already have a result from the first, 
  //                            // and if so do not post to both the first and the second actor
  //                            // because the first is done and the second *MUST* have that result in its inbox
  //                            // (when the first actor was called with non-empty caller id, the result of the first
  //                            // call is "atomically" added to the second actor inbox. (atomically means 
  //                            // that if actor.GetResultAsync() returned then the intermediate result
  //                            // is already in cActor inbox).
  //                            // (Such a situation when firstIsDone is more likely with continuations that could be chained mutiple times.)
  //                            let firstIsDone, _ = actor1.TryGetResultIfItDefinitelyExists(resultId)
  //                            if firstIsDone then // extremely unusual
  //                                // The first result must be already in the second inbox/pipeline
  //                                // Do not need to get the intermediate result here, do nothing
  //                                ()
  //                            else // normal case
  //                                // here the task message is sent to the first actor and 
  //                                // it will arrive to the results list and stay there
  //                                // before the results timeout
  //                                let envelope : Envelope<'Task> = inMessage, resultId, [| actor2.Id |]
  //                                actor1.Post(envelope) |> ignore
  //                                // do not wait for intermediate result
  //                                ()
  //                            // wait for second actor
  //                            let! r2 = actor2.GetResultAsync(resultId)
  //                            Debug.Print("Final result: " + r2.ToString())
  //                            return r2
  //                    }
  //            
  //            let result = 
  //                { new Actor<'Task, 'TResult2>() with
  //                       override __.Redis with get() = actor1.RedisConnectionString
  //                       override __.GetKey() = "(" + this.GetKey() + "->>-" + continuation.GetKey() + ")"
  //                       override __.ResultTimeout with get() = this.ResultTimeout + continuation.ResultTimeout
  //                       //instead of [override __.Computation(input) = ...] assign internal computation directly
  //                }
  //            // overwrite the default computation that ignores resultId with the proper one
  //            result.ExtendedComputation <- computation
  //            result
  //    //#endregion
  
  
  
negative.code:                                     // it will arrive to the results list and stay there
                                      // before the results timeout
                                      let envelope : Envelope<'Task> = inMessage, resultId, [| actor2.Id |]
                                      do! actor1.Post(envelope) |> Async.Ignore
                                      // do not wait for intermediate result
                                      ()
                                  // wait for second actor
  