anchor.diff:      
           new Actor<'T>(name, newProtocols, currentBehavior, linkedActors)
       
  -    abstract Publish: IProtocolServer<'T>[] -> Actor<'T>
  +    /// <summary>
  +    ///     Publishes given actor to collection of protocol server instances.
  +    /// </summary>
  +    /// <param name="protocolServers">Protocol servers to be published to.</param>
  +    abstract Publish: protocolServers:IProtocolServer<'T>[] -> Actor<'T>
       default self.Publish(protocols': IProtocolServer<'T>[]) = self.Publish(fun _ -> protocols')
       
  -    abstract Publish: #seq<'U>  -> Actor<'T> when 'U :> IProtocolFactory
  +    /// <summary>
  +    ///     Publishes given actor to collection of protocol factories.
  +    /// </summary>
  +    /// <param name="protocolFactories">Protocol factories to be published to.</param>
  +    abstract Publish: protocolFactories:#seq<'U>  -> Actor<'T> when 'U :> IProtocolFactory
       default self.Publish(protocolFactories: #seq<'U> when 'U :> IProtocolFactory) =
           self.Publish(fun actorRef -> protocolFactories |> Seq.map (fun factory -> factory.CreateServerInstance<'T>(name, actorRef)) |> Seq.toArray)
       
  -    abstract Rename: string -> Actor<'T>
  +    /// <summary>
  +    ///     Creates a renamed copy of given actor.
  +    /// </summary>
  +    /// <param name="newName">new name for given actor.</param>
  +    abstract Rename: newName:string -> Actor<'T>
       default actor.Rename(newName: string): Actor<'T> =
           //first check new name
           if newName.Contains("/") then invalidArg "newName" "Actor names must not contain '/'."
  
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)
  