anchor.diff:          member __.BasePreRestart(exn, msg) = base.PreRestart (exn, msg)
           member __.BasePostRestart(exn) = base.PostRestart (exn)
   
  -        member __.Next (current : Decorator<'Message>) (context : Actor<'Message>) (message : obj) : Decorator<'Message> = 
  +        member __.Next (current : ContWrapper<'Message, 'Returned>) (context : Actor<'Message>) (message : obj) : ContWrapper<'Message, 'Returned> = 
               match message with
               | :? 'Message as msg -> 
                   match current with
  -                | :? Become<'Message> as become -> become.Next msg
  +                | :? Become<'Message, 'Returned> as become -> become.Next msg
                   | _ -> current
               | other -> 
                   base.Unhandled other
  
positive.code:                 finallyExpr()
                  reraise()
      
          member this.Using(disposable : #IDisposable, continuation : _ -> Decorator<'In>) : Decorator<'In> = 
              this.TryFinally((fun () -> continuation disposable), fun () -> if disposable <> null then disposable.Dispose())
      
          member this.While(condition : unit -> bool, continuation : unit -> Decorator<'In>) : Decorator<'In> = 
              if condition() then 
                  match continuation() with
                  | Become next -> 
                      Become (fun message -> 
                          next message |> ignore
                          this.While(condition, continuation)) :> Decorator<'In>
                  | _ -> this.While(condition, continuation)
              else Empty :> Decorator<'In>
      
          member __.For(iterable : 'Iter seq, continuation : 'Iter -> Decorator<'In>) : Decorator<'In> = 
              use e = iterable.GetEnumerator()
          
              let rec loop() = 
  
negative.code:     /// <param name="name">Name of spawned child actor</param>
      /// <param name="f">Used by actor for handling response for incoming request</param>
      /// <param name="overrides">Functions used to override standard actor lifetime</param>
      let spawnOvrd (actorFactory : IActorRefFactory) (name : string) (f : Actor<'Message> -> ContWrapper<'Message, 'Returned>)
          (overrides : LifecycleOverride) : IActorRef = 
          spawnOptOvrd actorFactory name f [] overrides
  
      /// <summary>
      /// Wraps provided function with actor behavior. 
      /// It will be invoked each time, an actor will receive a message. 
      /// </summary>
      let actorOf (fn : 'Message -> #ContWrapper<'Message, 'Returned>) (mailbox : Actor<'Message>) : ContWrapper<'Message, 'Returned> = 
          let rec loop() = 
              actor { 
                  let! msg = mailbox.Receive()
  