anchor.diff:  /// <param name="system">The system used to spawn the actor</param>
   /// <param name="name">The actor instance nane</param>
   /// <param name="f">the actor's message handling function.</param>
  -let spawne (system:ActorSystem) name (f: Expr<Actor<'m> -> Cont<'m,'v>>)  =
  -    let e = Linq.Expression.ToExpression(fun () -> new FunActor<'m,'v>(f))
  +let spawne (system : ActorSystem) name (f : Expr<Actor<'m> -> Cont<'m, 'v>>) = 
  +    let e = Linq.Expression.ToExpression(fun () -> new FunActor<'m, 'v>(f))
       system.ActorOf(Props.Create(e), name)
  -   
  +
   /// <summary>
   /// Spawns an actor using specified actor computation expression, with strategy supervisor factory.
   /// The actor can only be used locally. 
  
positive.code: /// </summary>
  let actor = ActorBuilder()
  
  module Linq =
      open System.Linq.Expressions
  
      let (|Lambda|_|) (e:Expression) =
          match e with
          | :? LambdaExpression as l -> Some(l.Parameters, l.Body)
          | _ -> None
      let (|Call|_|) (e:Expression) =
          match e with
          | :? MethodCallExpression as c -> Some(c.Object,c.Method,c.Arguments)
          | _ -> None
  
      let (|Method|) (e:System.Reflection.MethodInfo) = e.Name
      let (|Invoke|_|) =
          function
          | Call(o,Method("Invoke"),_) -> Some o
          | _ -> None
      let (|Ar|) (p:System.Collections.ObjectModel.ReadOnlyCollection<Expression>) = Array.ofSeq p
      type Expression =
          static member ToExpression (f:System.Linq.Expressions.Expression<System.Func<FunActor<'m,'v>>>) =
              match f with
              | Lambda(_,Invoke(Call(null, Method "ToFSharpFunc", Ar [|Lambda(_,p)|]))) ->
                  Expression.Lambda(p,[||]) :?> System.Linq.Expressions.Expression<System.Func<FunActor<'m,'v>>>
              | _ -> failwith "Doesn't match"
  
  module Serialization =
      open Nessos.FsPickler
  
      open Akka.Serialization
      open Quotations.Patterns
  
      type ExprSerializer(system) =
          
          inherit Serializer(system)
          
  
          let fsp = FsPickler.CreateBinary()
          override x.Identifier = 9
          override x.IncludeManifest = true
  
          override x.ToBinary(o) =
              use stream = new System.IO.MemoryStream()
              fsp.Serialize(o.GetType(),stream, o)
              stream.ToArray()           
           
          override x.FromBinary(bytes, t) =
              use stream = new System.IO.MemoryStream(bytes)
              fsp.Deserialize(t, stream)
            
  module Configuration =
      let parse = Akka.Configuration.ConfigurationFactory.ParseString
  
  module Strategy =
      /// <summary>
      /// Returns a builder function returning OneForOneStrategy supervisor based on provided decider func.
      /// </summary>
      /// <param name="decider">Supervisor strategy behavior decider function.</param>
      let oneForOne (decider: Exception -> Directive) = 
          OneForOneStrategy(System.Func<_,_>(decider)) :> SupervisorStrategy
  
      /// <summary>
      /// Returns a builder function returning OneForOneStrategy supervisor based on provided decider func.
      /// </summary>
      /// <param name="retries">Number of times, actor could be restarted. If negative, there is not limit.</param>
      /// <param name="timeout">Time window for number of retries to occur.</param>
      /// <param name="decider">Supervisor strategy behavior decider function.</param>
      let oneForOne' retries timeout (decider: Exception -> Directive) = 
          OneForOneStrategy(retries, timeout, System.Func<_,_>(decider)) :> SupervisorStrategy
  
      /// <summary>
      /// Returns a builder function returning AllForOneStrategy supervisor based on provided decider func.
      /// </summary>
      /// <param name="decider">Supervisor strategy behavior decider function.</param>
      let allForOne (decider: Exception -> Directive) = 
          AllForOneStrategy(System.Func<_,_>(decider)) :> SupervisorStrategy
  
      /// <summary>
      /// Returns a builder function returning AllForOneStrategy supervisor based on provided decider func.
      /// </summary>
      /// <param name="retries">Number of times, actor could be restarted. If negative, there is not limit.</param>
      /// <param name="timeout">Time window for number of retries to occur.</param>
      /// <param name="decider">Supervisor strategy behavior decider function.</param>
      let allForOne' retries timeout (decider: Exception -> Directive) () = 
          AllForOneStrategy(retries, timeout, System.Func<_,_>(decider)) :> SupervisorStrategy
  
  module System =
      /// <summary>
      /// Creates an actor system with remote deployment serialization enabled.
      /// </summary>
      /// <param name="name">The system name.</param>
      /// <param name="configStr">The configuration</param>
      let create name (config: Configuration.Config) =
          let system = ActorSystem.Create(name, config)
          let serializer = new Serialization.ExprSerializer(system :?> ExtendedActorSystem)
          system.Serialization.AddSerializer(serializer)
  
negative.code:         /// <param name="name">The actor instance name to be created as child of current actor</param>
          /// <param name="strategy">Function used to generate supervisor strategy</param>
          /// <param name="f">the actor's message handling function.</param>
          member this.spawns name (strategy : SupervisorStrategy) (f : Actor<'m> -> Cont<'m, 'v>) = 
              let e = Linq.Expression.ToExpression(fun () -> new FunActor<'m, 'v>(f, strategy))
              this.Context.ActorOf(Props.Create(e), name)
          
          /// <summary>
          /// Implementation of spawn method using actor-local context.
          /// Actor refs returned this way are considered children of current actor.
          /// </summary>
          member this.spawn name (f : Actor<'m> -> Cont<'m, 'v>) = this.spawns name null f
  