anchor.diff:                  override actor.Ref = actorRef
           }
   
  -    let spawnMany (processFunc: 'T -> Async<unit>) (howMany: int) (balancer: seq<ActorRef<'T>> -> ActorRef<'T>): Actor<'T> =
  -        [ for i in 1..howMany -> spawn processFunc ] |> balance balancer
  -
  +
  +//    let spawnMany (processFunc: 'T -> Async<unit>) (howMany: int) (balancer: seq<ActorRef<'T>> -> ActorRef<'T>): Actor<'T> =
  +//        [ for i in 1..howMany -> spawn processFunc ] |> balance balancer
  +
  +    /// <summary>
  +    ///     Creates a new actor that forwards boxed messages to target.
  +    /// </summary>
  +    /// <param name="actor">Target actor.</param>
       let box (actor: Actor<'T>): Actor<obj> =
           actor |> map (fun msg -> msg :?> 'T)
   
  +    /// <summary>
  +    ///     Creates a new actor that forwards unboxed messages to target.
  +    /// </summary>
  +    /// <param name="actor">Target actor.</param>
       let unbox (actor: Actor<obj>): Actor<'T> =
           actor |> map (fun msg -> msg :> obj)
   
  +    /// <summary>
  +    ///     Fuse constituent actors into one that accepts union types.
  +    /// </summary>
  +    /// <param name="actor"></param>
  +    /// <param name="actor'"></param>
       let union (actor: Actor<'T>) (actor': Actor<'U>): Actor<Choice<'T, 'U>> =
           spawnLinked (fun msg -> async {
               match msg with
  -            | Choice1Of2 m -> !actor <-- m
  -            | Choice2Of2 m -> !actor' <-- m
  +            | Choice1Of2 m -> return! !actor <-!- m
  +            | Choice2Of2 m -> return! !actor' <-!- m
           }) [actor |> box; actor' |> box]
   
  -[<AutoOpen>]
  -module ActorRefExtensions =
  -    module ActorRef =
  -        let inline configurationFilter (filterF: IProtocolFactory -> bool) (actorRef: ActorRef<'T>): ActorRef<'T> = actorRef.ProtocolFilter filterF
  -        let inline empty() = Actor.sink() |> Actor.ref
  -
  +/// Collection of ActorRef combinators
  +[<RequireQualifiedAccess>]
  +[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  +module ActorRef =
  +        
  +    /// <summary>
  +    ///     Filters actor ref protocols by predicate.
  +    /// </summary>
  +    /// <param name="filterF">Protocol filtering function.</param>
  +    /// <param name="actorRef">Input ActorRef.</param>
  +    /// <returns>ActorRef with filtered protocol configurations.</returns>
  +    let inline configurationFilter (filterF: IProtocolFactory -> bool) (actorRef: ActorRef<'T>): ActorRef<'T> = actorRef.ProtocolFilter filterF
  +
  +    /// <summary>
  +    ///     Return reference to a new actor that accepts one message and then exits.
  +    /// </summary>
  +    let inline empty() = Actor.sink() |> Actor.ref
  +
  +
  +/// Collection of behaviour-based combinators
  +[<RequireQualifiedAccess>]
   module Behavior =
  -    module WithSelf =
  -        let rec stateful (state: 'U) (behavior: 'U -> ActorRef<'T> -> 'T -> Async<'U>) (self: Actor<'T>) =
  -            async {
  -                let! msg = self.Receive()
  -
  -                let! state' = behavior state !self msg
  -
  -                return! stateful state' behavior self
  -            }
  -
  -        let stateless (behavior: ActorRef<'T> -> 'T -> Async<unit>) =
  -            stateful () (fun _ self msg -> behavior self msg)
  -      
  -    let rec stateful (state: 'U) (behavior: 'U -> 'T -> Async<'U>) = WithSelf.stateful state (fun state _ msg -> behavior state msg)
  -
  -    let rec stateful2 (state: 'U) (behavior: 'U -> Actor<'T> -> Async<'U>) (self : Actor<'T>) =
  +
  +    /// <summary>
  +    ///     Creates a stateful behaviour workflow out of provided components.
  +    /// </summary>
  +    /// <param name="init">Initial state.</param>
  +    /// <param name="behavior">State-updating reactive asynchronous workflow.</param>
  +    /// <param name="self">'This' actor.</param>
  +    let rec stateful (init: 'State) (behavior: 'State -> 'T -> Async<'State>) (self: Actor<'T>) : Async<unit> =
           async {
  -            let! state' = behavior state self
  -
  -            return! stateful2 state' behavior self
  +            let! msg = self.Receive()
  +
  +            let! state' = behavior init msg
  +
  +            return! stateful state' behavior self
           }
   
  +    /// <summary>
  +    ///     Creates a stateless behaviour workflow out of a message-reactive function.
  +    /// </summary>
  +    /// <param name="reactF">workflow that reacts asynchronously to input message.</param>
       let stateless (behavior: 'T -> Async<unit>) (self: Actor<'T>) =
  -        stateful () (fun _ msg -> behavior msg) self
  +        stateful () (fun _ msg -> behavior msg) self
positive.code:     
          new Actor<'T>(newName, newProtocols, currentBehavior, linkedActors)
      
      abstract Ref: ActorRef<'T>
      default actor.Ref = actorRef
      
      abstract Receive: ?timeout: int -> Async<'T>
      default __.Receive(?timeout: int) = let timeout = defaultArg timeout Timeout.Infinite in primaryProtocol.Receive(timeout)
      
      abstract TryReceive: ?timeout: int -> Async<'T option>
      default __.TryReceive(?timeout: int) = let timeout = defaultArg timeout Timeout.Infinite in primaryProtocol.TryReceive(timeout)
      
      override __.LogEvent<'L>(logLevel: LogLevel, datum: 'L) = logEvent.Trigger(logLevel, logSource, datum :> obj)
      
      override self.LogInfo<'L>(info: 'L) = self.LogEvent(Info, info)
      
      override self.LogWarning<'L>(warning: 'L) = self.LogEvent(Warning, warning)
      
      override self.LogError(e: exn) = self.LogEvent(Error, e)
      
      member private __.Start(behavior: Actor<'T> -> Async<unit>) =
          if not isStarted then
  
negative.code: 
  open Nessos.Thespian.Logging
  
  /// Represents an untyped locally executing actor instance.
  [<AbstractClass>]
  type Actor() =
      [<VolatileField>]
      static let mutable primaryProtocolFactory = new MailboxProtocol.MailboxPrimaryProtocolFactory() :> IPrimaryProtocolFactory
  
      /// Gets or sets the default primary protocol used by actors.
      static member DefaultPrimaryProtocolFactory 
          with get() = primaryProtocolFactory
          and set f = primaryProtocolFactory <- f
      
      /// Actor event observable
      abstract Log: IEvent<Log>
  
      /// <summary>
      ///     Trigger a new event for given actor.
      /// </summary>
      /// <param name="logLevel">Log level.</param>
      /// <param name="event">event value.</param>
      abstract LogEvent: logLevel:LogLevel * event:'E -> unit
  
      /// Starts given actor instance.
      abstract Start: unit -> unit
      /// Stops given actor instance.
      abstract Stop: unit -> unit
  
  type Actor<'T>(name: string, protocols: IProtocolServer<'T>[], behavior: Actor<'T> -> Async<unit>, ?linkedActors: seq<Actor>) as self =
  