anchor.diff:                  ActorsRegister.addActor a
                   a
   
  -    type BodyBulder<'TMessage>() =
  +    type BodyBulder() =
           member __.Zero() =  {
               OnReceive = fun m -> response(null)
               OnReminder = None
               OnActivate = None
               OnDeactivate = None
           }
  -        member x.Yield(()) : BodyConfiguration<'TMessage> = x.Zero()
  +        member x.Yield(()) : BodyConfiguration = x.Zero()
   
           [<CustomOperation("onReceive")>]
  -        member __.OnReceive(body, receive) : BodyConfiguration<'TMessage> = {body with OnReceive = receive}
  +        member __.OnReceive(body, receive) : BodyConfiguration = {body with OnReceive = receive}
   
           [<CustomOperation("onReminder", MaintainsVariableSpace = true)>]
  -        member __.OnReminder(body, reminder: string ->Task) : BodyConfiguration<'TMessage> =
  +        member __.OnReminder(body, reminder: string ->Task) : BodyConfiguration =
               { body with OnReminder = reminder|> Some }
   
           [<CustomOperation("onActivate", MaintainsVariableSpace = true)>]
  -        member __.OnActivate(body, activate) : BodyConfiguration<'TMessage> = { body with OnActivate = activate|> Some }
  +        member __.OnActivate(body, activate) : BodyConfiguration = { body with OnActivate = activate|> Some }
   
           [<CustomOperation("onDeactivate", MaintainsVariableSpace = true)>]
  -        member __.OnDeactivate(body, deactivate) : BodyConfiguration<'TMessage> =
  +        member __.OnDeactivate(body, deactivate) : BodyConfiguration =
               { body with OnDeactivate = deactivate |> Some }
   
  -let handlers<'a> = Builders.BodyBulder<'a>()
  +let handlers<'a> = Builders.BodyBulder()
   
  -let actor<'a> = Builders.ActorBuilder<'a>()
  +let actor<'a> = Builders.ActorBuilder()
   
   module ActorRegister = 
       
  
positive.code: //    type FSharpActor(actor: Configurations.ActorConfiguration<'a> ) = 
  //            inherit EndpointConfiguration(actor.Id)
  
      type FSharpInvoker(body: Configurations.BodyConfiguration<'a>)  = 
          interface IActorInvoker with 
              member __.OnActivate () =  
                                              match body.OnActivate  with
  
negative.code: let inline taskDone() = Task.FromResult(null) :> Task
  
  module Configurations =
      type BodyConfiguration = {
          OnReceive: obj -> Task<obj>
          OnReminder: (string -> Task) option
          OnActivate: (unit -> Task) option
          OnDeactivate: (unit -> Task) option
      }
  
      type ActorConfiguration =  {
          Id: string
          KeepAlive: System.TimeSpan
          Body: unit->BodyConfiguration
      }
  
  module ActorsRegister =
      open Configurations
  
      let mutable private actors  = Map.empty<string,ActorConfiguration>
  
      let addActor actor =
          actors<- actors.Add (actor.Id,actor)
  