anchor.diff:  //actor stuff
   type actor<'t> = MailboxProcessor<'t>
   
  +type Verb =
  +  | Get
  +  | Post
  +  | Put
  +  | Delete
  +
  +type Header =
  +  | ContentType of string
  +
  +type Request =
  +  {
  +    uri : string
  +    verb : Verb
  +    headers : Header list
  +  }
  +
   type Command =
  -  | Say of string
  -
  -type Worker =
  -  | Printer of int
  -  | Yeller of int
  +  | Process of Request
   
   type Manager =
  -  | Add of Worker
     | Do of Command
     | Start
     | Stop
  
positive.code:       async {
          let! msg = inbox.Receive ()
          match msg with
          | Send(jobId, message) ->
            let maybeManager = managers |> List.tryFind (fun (jobId', _) -> jobId' = jobId)
            match maybeManager with
            | Some(_, manager) ->
              manager.Post(Do(Say message))
              return! loop managers
            | None ->
              let manager = newManager()
              let worker = Printer 1
              manager.Post(Add(worker))
              manager.Post(Do(Say message))
              let managers = (jobId, manager) :: managers
              return! loop managers
          | Stop jobId ->
  
negative.code:   | Running
    | Stopped
  
  let doit (request : Request) =
    ()
  
  let newManager () : actor<Manager> =
    actor.Start(fun inbox ->
      let rec loop status =
        async {
          let! msg = inbox.Receive ()
          match msg with
          | Do command ->
            match status with
            | Stopped ->
              printfn "Can't do work when the job is stopped"
              return! loop status
            | Running ->
              match command with
              | Process req -> doit req
              //process command here
              return! loop status
          | Manager.Stop ->
            return! loop Stopped
          | Manager.Start ->
            return! loop Running
        }
      loop Stopped
    )
  
  let newJobManager () : actor<JobManager> =
  