anchor.diff:    | Running
     | Stopped
   
  +let doit (request : Request) =
  +  ()
  +
   let newManager () : actor<Manager> =
     actor.Start(fun inbox ->
  -    let rec loop status workers =
  +    let rec loop status =
         async {
           let! msg = inbox.Receive ()
           match msg with
  -        | Add worker ->
  -          let workers = workers @ [worker]
  -          return! loop status workers
           | Do command ->
             match status with
             | Stopped ->
               printfn "Can't do work when the job is stopped"
  -            return! loop status workers
  +            return! loop status
             | Running ->
  -            let worker = workers |> List.head
  -            let others = workers |> List.tail
               match command with
  -            | Say(message) ->
  -              match worker with
  -              | Printer(id) -> printfn "I am printer %i, my message is %s" id message
  -              | Yeller(id) -> printfn "I AM YELLER %i, my message is %s" id message
  -            let workers = others @ [worker]
  -            return! loop status workers
  +            | Process req -> doit req
  +            //process command here
  +            return! loop status
           | Manager.Stop ->
  -          return! loop Stopped workers
  +          return! loop Stopped
           | Manager.Start ->
  -          return! loop Running workers
  +          return! loop Running
         }
  -    loop Stopped []
  +    loop Stopped
     )
   
   let newJobManager () : actor<JobManager> =
  
positive.code: //actor stuff
  type actor<'t> = MailboxProcessor<'t>
  
  type Command =
    | Say of string
  
  type Worker =
    | Printer of int
    | Yeller of int
  
  type Manager =
    | Add of Worker
    | Do of Command
    | Start
    | Stop
  
negative.code:       async {
          let! msg = inbox.Receive ()
          match msg with
          | Send(jobId, _) ->
            let req =
              {
                uri = "http://localhost:8083"
                verb = Verb.Get
                headers = []
              }
            let maybeManager = managers |> List.tryFind (fun (jobId', _) -> jobId' = jobId)
            match maybeManager with
            | Some(_, manager) ->
              manager.Post(Do(Process req))
              return! loop managers
            | None ->
              let manager = newManager()
              manager.Post(Do(Process req))
              let managers = (jobId, manager) :: managers
              return! loop managers
          | Stop jobId ->
  