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: /// <param name="name">The actor instance name</param>
  /// <param name="strategy">Function used to generate supervisor strategy</param>
  /// <param name="f">the actor's message handling function.</param>
  let spawns (system:ActorSystem) name (strategy: SupervisorStrategy) (f: Actor<'m> -> Cont<'m,'v>)  =
      let e = Linq.Expression.ToExpression(fun () -> new FunActor<'m,'v>(f, strategy))
      system.ActorOf(Props.Create(e), name)
  
  /// <summary>
  
negative.code: ﻿module Akka.FSharp
  
  open Akka.Actor
  open System
  
  type IO<'msg> = 
      | Input
  
  [<Interface>]
  type Actor<'msg> = 
      abstract Receive : unit -> IO<'msg>
      abstract Self : ActorRef
      abstract Context : IActorContext
      abstract Sender : unit -> ActorRef
      abstract Unhandled : 'msg -> unit
  
  [<AbstractClass>]
  type Actor() = 
      inherit Akka.Actor.UntypedActor()
  
  let inline select (path : string) : ActorSelection = ActorSelection(ActorCell.GetCurrentSelfOrNoSender(), path)
  let inline (<!) (actorRef : #ICanTell) (msg : obj) = actorRef.Tell(msg, ActorCell.GetCurrentSelfOrNoSender())
  let inline (!>) (msg : obj) (actorRef : #ICanTell) = actorRef <! msg
  let inline (<?) (tell : #ICanTell) (msg : obj) = tell.Ask msg |> Async.AwaitTask
  let inline (?>) (msg : obj) (actorRef : #ICanTell) = actorRef <? msg
  
  module ActorSelection = 
      let inline (<!) (actorPath : string) (msg : obj) = (select actorPath) <! msg
      let inline (<?) (actorPath : string) (msg : obj) = (select actorPath) <? msg
  
  type ActorPath with
      
      static member TryParse(path : string) = 
          let mutable actorPath : ActorPath = null
          if ActorPath.TryParse(path, &actorPath) then Some actorPath
          else None
      
      static member TryParseAddress(path : string) = 
          let mutable address : Address = null
          if ActorPath.TryParseAddress(path, &address) then Some address
          else None
  
  /// <summary>
  /// Gives access to the next message throu let! binding in
  /// actor computation expression.
  /// </summary>
  type Cont<'m, 'v> = 
      | Func of ('m -> Cont<'m, 'v>)
      | Return of 'v
  
  /// <summary>
  /// The builder for actor computation expression<
  /// </summary>
  type ActorBuilder() = 
      // binds the next message
      member this.Bind(m : IO<'msg>, f : 'msg -> _) = Func(fun m -> f m)
      
      // binds the result of another actor computation expression
      member this.Bind(x : Cont<'m, 'a>, f : 'a -> Cont<'m, 'b>) : Cont<'m, 'b> = 
          match x with
          | Func fx -> Func(fun m -> this.Bind(fx m, f))
          | Return v -> f v
      
      member this.ReturnFrom(x) = x
      member this.Return x = Return x
      member this.Zero() = Return()
      
      member this.TryWith(f : unit -> Cont<'m, 'a>, c : exn -> Cont<'m, 'a>) : Cont<'m, 'a> = 
          try 
              true, f()
          with ex -> false, c ex
          |> function 
          | true, Func fn -> Func(fun m -> this.TryWith((fun () -> fn m), c))
          | _, v -> v
      
      member this.TryFinally(f : unit -> Cont<'m, 'a>, fnl : unit -> unit) : Cont<'m, 'a> = 
          try 
              match f() with
              | Func fn -> Func(fun m -> this.TryFinally((fun () -> fn m), fnl))
              | r -> 
                  fnl()
                  r
          with ex -> 
              fnl()
              reraise()
      
      member this.Using(d : #IDisposable, f : _ -> Cont<'m, 'v>) : Cont<'m, 'v> = 
          this.TryFinally((fun () -> f d), 
                          fun () -> 
                              if d <> null then d.Dispose())
      
      member this.While(condition : unit -> bool, f : unit -> Cont<'m, unit>) : Cont<'m, unit> = 
          if condition() then 
              match f() with
              | Func fn -> 
                  Func(fun m -> 
                      fn m |> ignore
                      this.While(condition, f))
              | v -> this.While(condition, f)
          else Return()
      
      member this.For(source : 's seq, f : 's -> Cont<'m, unit>) : Cont<'m, unit> = 
          use e = source.GetEnumerator()
          
          let rec loop() = 
              if e.MoveNext() then 
                  match f e.Current with
                  | Func fn -> 
                      Func(fun m -> 
                          fn m |> ignore
                          loop())
                  | r -> loop()
              else Return()
          loop()
      
      member this.Delay(f : unit -> Cont<_, _>) = f
      member this.Run(f : unit -> Cont<_, _>) = f()
      member this.Run(f : Cont<_, _>) = f
      
      member this.Combine(f : unit -> Cont<'m, _>, g : unit -> Cont<'m, 'v>) : Cont<'m, 'v> = 
          match f() with
          | Func fx -> Func(fun m -> this.Combine((fun () -> fx m), g))
          | Return _ -> g()
      
      member this.Combine(f : Cont<'m, _>, g : unit -> Cont<'m, 'v>) : Cont<'m, 'v> = 
          match f with
          | Func fx -> Func(fun m -> this.Combine(fx m, g))
          | Return _ -> g()
      
      member this.Combine(f : unit -> Cont<'m, _>, g : Cont<'m, 'v>) : Cont<'m, 'v> = 
          match f() with
          | Func fx -> Func(fun m -> this.Combine((fun () -> fx m), g))
          | Return _ -> g
      
      member this.Combine(f : Cont<'m, _>, g : Cont<'m, 'v>) : Cont<'m, 'v> = 
          match f with
          | Func fx -> Func(fun m -> this.Combine(fx m, g))
          | Return _ -> g
  
  open Microsoft.FSharp.Quotations
  open Microsoft.FSharp.Linq.QuotationEvaluation
  
  type FunActor<'m, 'v>(actor : Actor<'m> -> Cont<'m, 'v>, strategy : SupervisorStrategy) as self = 
      inherit UntypedActor()
      
      let mutable state = 
          let self' = self.Self
          let context' = UntypedActor.Context :> IActorContext
          actor { new Actor<'m> with
                      member this.Receive() = Input
                      member this.Self = self'
                      member this.Context = context'
                      member this.Sender() = self.Sender()
                      member this.Unhandled msg = self.Unhandled msg }
      
      new(actor : Expr<Actor<'m> -> Cont<'m, 'v>>) = FunActor(actor.Compile () ())
      new(actor : Actor<'m> -> Cont<'m, 'v>) = FunActor(actor, null)
      member x.Sender() = base.Sender
      member x.Unhandled(msg : 'm) = base.Unhandled msg
      
      override x.SupervisorStrategy() = 
          if strategy <> null then strategy
          else base.SupervisorStrategy()
      
      override x.OnReceive(msg) = 
          let message = msg :?> 'm
          match state with
          | Func f -> state <- f message
  