anchor.diff:  
   module Lifecycle =
       
  +    open System
       open Akka.Actor
       open Akka.FSharp
       open Akka.FSharp.Linq
       open Microsoft.FSharp.Linq
  +    open Microsoft.FSharp.Quotations
  +    open Microsoft.FSharp.Linq.QuotationEvaluation
   
       type LifecycleOverride =
           {
  
positive.code:         actorFactory.ActorOf(props, name)
  
      /// <summary>
      /// Spawns an actor using specified actor computation expression.
      /// The actor can only be used locally. 
      /// </summary>
  
negative.code:     and [<Struct>]Become<'Message>(next: 'Message -> Decorator<'Message>) =
          member x.Next = next
          interface Decorator<'Message>
      and [<Struct>]AsyncDecorator<'Message>(asyncDecorator: Async<Decorator<'Message>>) =
          member __.Decorator = asyncDecorator
          interface Decorator<'Message>
  
      type ExpressionExt = 
          static member ToExpression(f : System.Linq.Expressions.Expression<System.Func<FunActorExt<'Message, 'v>>>) = toExpression<FunActorExt<'Message, 'v>> f
          static member ToExpression<'Actor>(f : Quotations.Expr<(unit -> 'Actor)>) = toExpression<'Actor> (QuotationEvaluator.ToLinqExpression f)
  
      
      let (|Become|_|) (effect: Decorator<'Message>) =
          if effect :? Become<'Message>
          then Some ((effect :?> Become<'Message>).Next)
          else None
  
      /// Gives access to the next message throu let! binding in actor computation expression.
      //type Behavior<'In, 'Out> = 
      //    | Become of ('In -> Behavior<'In, 'Out>)
      //    | Return of 'Out
  
      /// The builder for actor computation expression.
      type ActorBuilder() =
          member __.Bind(_ : IO<'In>, continuation : 'In -> Decorator<'In>) : Decorator<'Message> = upcast Become(fun message -> continuation message)
          member this.Bind(behavior : Decorator<'In>, continuation : Decorator<'In> -> Decorator<'In>) : Decorator<'In> = 
              match behavior with
              | :? Become<'In> as become -> Become<'In>(fun message -> this.Bind(become.Next message, continuation)) :> Decorator<'In>
              | returned -> continuation returned    
          member __.Bind(asyncInput: Async<'In>, continuation: 'In -> Decorator<'Out>) : Decorator<'Out> =
              upcast AsyncDecorator (async {
                  let! returned = asyncInput 
                  return continuation returned 
              })
          member __.ReturnFrom (effect: Decorator<'Message>) = effect
          member __.Return (value: Decorator<'Message>) : Decorator<'Message> = value
          member __.Zero () : Decorator<'Message> = Empty :> Decorator<'Message>
          member __.Yield value = value
  
          member this.TryWith(tryExpr : unit -> Decorator<'In>, catchExpr : exn -> Decorator<'In>) : Decorator<'In> = 
              try 
                  true, tryExpr ()
              with error -> false, catchExpr error
              |> function 
              | true, Become(next) -> Become<'In>(fun message -> this.TryWith((fun () -> next message), catchExpr)) :> Decorator<'In>
              | _, value -> value    
  
          member this.TryFinally(tryExpr : unit -> Decorator<'In>, finallyExpr : unit -> unit) : Decorator<'In> = 
              try 
                  match tryExpr() with
                  | Become next -> Become(fun message -> this.TryFinally((fun () -> next message), finallyExpr)) :> Decorator<'In>
                  | behavior -> 
                      finallyExpr()
                      behavior
              with error -> 
                  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() = 
                  if e.MoveNext() then 
                      match continuation e.Current with
                      | Become fn -> 
                          Become(fun m -> 
                              fn m |> ignore
                              loop()) :> Decorator<'In>
                      | _ -> loop()
                  else Empty :> Decorator<'In>
              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> = 
              match first () with
              | Become next -> Become(fun message -> this.Combine((fun () -> next message), second)) :> Decorator<'In>
              | _ -> second ()
      
          member this.Combine(first : Decorator<'In>, second : unit -> Decorator<'In>) : Decorator<'In> = 
              match first with
              | Become next -> Become(fun message -> this.Combine(next message, second)) :> Decorator<'In>
              | _ -> second ()
      
          member this.Combine(first : unit -> Decorator<'In>, second : Decorator<'In>) : Decorator<'In> = 
              match first () with
              | Become next -> Become(fun message -> this.Combine((fun () -> next message), second)) :> Decorator<'In>
              | _ -> second
      
          member this.Combine(first : Decorator<'In>, second : Decorator<'In>) : Decorator<'In> = 
              match first with
              | Become next -> Become(fun message -> this.Combine(next message, second)) :> Decorator<'In>
              | _ -> second
          
      /// Builds an actor message handler using an actor expression syntax.
      let actor = ActorBuilder()
  
      /// <summary>
      /// Spawns an actor using specified actor computation expression, with custom spawn option settings.
  