anchor.diff:                      | Become fn -> 
                           Become(fun m -> 
                               fn m |> ignore
  -                            loop()) :> Decorator<'In>
  +                            loop()) :> ContWrapper<'In, 'Out>
                       | _ -> loop()
  -                else Empty :> Decorator<'In>
  +                else Empty :> ContWrapper<'In, 'Out>
               loop()
       
  -        member __.Delay(continuation : unit -> Decorator<'In>) = continuation
  -        member __.Run(continuation : unit -> Decorator<'In>) = continuation ()
  -        member __.Run(continuation : Decorator<'In>) = continuation
  -    
  -        member this.Combine(first : unit -> Decorator<'In>, second : unit -> Decorator<'In>) : Decorator<'In> = 
  +        member __.Delay(continuation : unit -> ContWrapper<'In, 'Out>) = continuation
  +        member __.Run(continuation : unit -> ContWrapper<'In, 'Out>) = continuation ()
  +        member __.Run(continuation : ContWrapper<'In, 'Out>) = continuation
  +    
  +        member this.Combine(first : unit -> ContWrapper<'In, 'Out>, second : unit -> ContWrapper<'In, 'Out>) : ContWrapper<'In, 'Out> = 
               match first () with
  -            | Become next -> Become(fun message -> this.Combine((fun () -> next message), second)) :> Decorator<'In>
  +            | Become next -> Become(fun message -> this.Combine((fun () -> next message), second)) :> ContWrapper<'In, 'Out>
               | _ -> second ()
       
  -        member this.Combine(first : Decorator<'In>, second : unit -> Decorator<'In>) : Decorator<'In> = 
  +        member this.Combine(first : ContWrapper<'In, 'Out>, second : unit -> ContWrapper<'In, 'Out>) : ContWrapper<'In, 'Out> = 
               match first with
  -            | Become next -> Become(fun message -> this.Combine(next message, second)) :> Decorator<'In>
  +            | Become next -> Become(fun message -> this.Combine(next message, second)) :> ContWrapper<'In, 'Out>
               | _ -> second ()
       
  -        member this.Combine(first : unit -> Decorator<'In>, second : Decorator<'In>) : Decorator<'In> = 
  +        member this.Combine(first : unit -> ContWrapper<'In, 'Out>, second : ContWrapper<'In, 'Out>) : ContWrapper<'In, 'Out> = 
               match first () with
  -            | Become next -> Become(fun message -> this.Combine((fun () -> next message), second)) :> Decorator<'In>
  +            | Become next -> Become(fun message -> this.Combine((fun () -> next message), second)) :> ContWrapper<'In, 'Out>
               | _ -> second
       
  -        member this.Combine(first : Decorator<'In>, second : Decorator<'In>) : Decorator<'In> = 
  +        member this.Combine(first : ContWrapper<'In, 'Out>, second : ContWrapper<'In, 'Out>) : ContWrapper<'In, 'Out> = 
               match first with
  -            | Become next -> Become(fun message -> this.Combine(next message, second)) :> Decorator<'In>
  +            | Become next -> Become(fun message -> this.Combine(next message, second)) :> ContWrapper<'In, 'Out>
               | _ -> second
           
       /// Builds an actor message handler using an actor expression syntax.
  
positive.code:         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> = 
              match message with
              | :? 'Message as msg -> 
                  match current with
                  | :? Become<'Message> as become -> become.Next msg
                  | _ -> current
              | other -> 
                  base.Unhandled other
  
negative.code:     /// <param name="f">Used by actor for handling response for incoming request</param>
      /// <param name="options">List of options used to configure actor creation</param>
      /// <param name="overrides">Functions used to override standard actor lifetime</param>
      let spawnOptOvrd (actorFactory : IActorRefFactory) (name : string) (f : Actor<'Message> -> ContWrapper<'Message, 'Returned>) 
          (options : SpawnOption list) (overrides : LifecycleOverride) : IActorRef = 
          let toContFromWrapper (f : Actor<'Message> -> ContWrapper<'Message, 'Returned>) : Actor<'Message> -> Cont<'Message, 'Returned> =
              let continuation a = f(a).Continuation
              continuation
          let e = ExpressionExt.ToExpression(fun () -> new FunActorExt<'Message, 'Returned>(toContFromWrapper f, overrides))
          let props = applySpawnOptions (Props.Create e) options
          actorFactory.ActorOf(props, name)
  
  