anchor.diff:      new (behavior: Actor<'T> -> Async<unit>, ?primaryProtocolFactory: IPrimaryProtocolFactory, ?linkedActors: seq<Actor>) = new Actor<'T>(String.Empty, behavior, ?primaryProtocolFactory = primaryProtocolFactory, ?linkedActors = linkedActors)
       new (otherActor: Actor<'T>) = new Actor<'T>(otherActor.Name, protocols = otherActor.Protocols, behavior = otherActor.Behavior, linkedActors = otherActor.LinkedActors)
       
  +    /// Protocol server instances used by the actor
       member private __.Protocols = protocols
  +    /// Asynchronous, tail-recursive loop behaviour used by actor.
       member private __.Behavior = behavior
  +    /// Actors linked to the given actor instance.
       member private __.LinkedActors = linkedActors
       
  +    /// Actor name
       member __.Name = name
       
       override __.Log = logEvent.Publish
       
  -    member __.PendingMessages with get() = primaryProtocol.PendingMessages
  +    /// Return the number of messages pending processing by actor instance.
  +    member __.PendingMessages = primaryProtocol.PendingMessages
       
       member private __.Publish(newProtocolsF: ActorRef<'T> -> IProtocolServer<'T>[]) =
           let primaryProtocol' = primaryProtocol.CreateInstance(name)
  
positive.code: 
  open Nessos.Thespian.Logging
  
  [<AbstractClass>]
  type Actor() =
      [<VolatileField>]
      static let mutable primaryProtocolFactory = new MailboxProtocol.MailboxPrimaryProtocolFactory() :> IPrimaryProtocolFactory
  
      static member DefaultPrimaryProtocolFactory with get() = primaryProtocolFactory
                                                   and set f = primaryProtocolFactory <- f
      
      abstract Log: IEvent<Log>
      abstract LogEvent: LogLevel * 'E -> unit
      abstract LogInfo: 'I -> unit
      abstract LogWarning: 'W -> unit
      abstract LogError: exn -> unit
      abstract Start: unit -> unit
      abstract Stop: unit -> unit
  
  type Actor<'T>(name: string, protocols: IProtocolServer<'T>[], behavior: Actor<'T> -> Async<unit>, ?linkedActors: seq<Actor>) as self =
  
negative.code:     let mutable linkedErrorRemoves: IDisposable list = []
      let mutable protocolLogSubscriptions: IDisposable list = []
      let logSource = LogSource.Actor name
      let linkedActors = match linkedActors with None -> [||] | Some la -> Seq.toArray la
      let logEvent = new Event<Log>()
      let primaryProtocol = protocols.[0] :?> IPrimaryProtocolServer<'T>
      let clientProtocols = protocols |> Array.map (fun protocol -> protocol.Client)
  