anchor.diff:                      return OK msgs
                   }
               }
  -
  -            Json.GET "/messages/since/{id:%s}" {
  -                Resource = "Message"; Action = "GetSince"
  -                Description = "Returns all the messages since the given id."
  -                Handle = fun () lastId -> async {
  -                    let! msgs = messageBox.PostAndTryAsyncReply(fun c -> 
  -                                    GetSince(Some(Guid.Parse lastId), c))
  -                    return OK msgs
  -                }
  -            }
           ] 
  +    // Here we specify that the API should publish metadata.
  +    // This allows us to hook into the API in a type safe way from the
  +    // HashBangAPI type provider in .NET and FunScript/JS clients. 
       |> Website.WithMetadata
  +    // This runs the server.
       |> Website.Start
   
   [<EntryPoint>]
  
positive.code:                 | Some lastId -> id <> lastId)
              |> Seq.map (fun (id, msg) -> id.ToString(), msg)
              |> Seq.toArray |> channel.Reply
          let rec loop msgs waiting =
              async {
                  let! command = inbox.Receive()
                  match command with
                  | GetSince(lastId, channel) ->
                      match List.tryHead msgs with
                      | Some(id, _) when Some id <> lastId ->
                          notify msgs (lastId, channel)
                          return! loop msgs waiting
                      | Some _ | None ->
                          return! loop msgs ((lastId, channel) :: waiting)
                  | Send msg ->
                      let id = Guid.NewGuid()
                      let newMsgs = (id, msg) :: msgs
                      waiting |> List.iter (notify newMsgs)
                      return! loop newMsgs []
              }
          loop [] []
      )
  
  let createServer() =
      Website.At "http://*:8080/"
      |> Website.WithRouteHandlers 
          [
              Json.POST "/messages" { 
                  Resource = "Message"; Action = "Send"
                  Description = "Broadcasts a new message."
                  Handle = fun (message : Message, ()) () -> async {
                      messageBox.Post(Send message)
                      return OK message
                  }
              }
  
  
negative.code: open TypeInferred.HashBang
  open ChatExample.Shared
  
  // Here are some list extensions.
  module List =
      // Returns nothing if the list is empty. 
      // Otherwise, returns the head of the list.
      let tryHead = function
          | [] -> None
          | x::_ -> Some x
  
  // Here we define the commands that our messageBox agent can process.
  type MessageBoxCommand =
      /// Sends a message to all clients and stores the message in the box.
      | Send of Message
      /// Returns all the messages since the message id provided.
      | GetSince of Guid option * AsyncReplyChannel<(string * Message)[]>
  
  // Here we define a messageBox agent that controls the server state.
  // It keeps track of messages and clients that are long-polling.
  let messageBox =
      MailboxProcessor.Start(fun inbox ->
          /// Given a client's channel and the last message identifier
          /// it saw, this function returns all messages after that message.
          let notify msgs (lastId, channel : AsyncReplyChannel<_>) =
              msgs |> Seq.takeWhile (fun (id, _) -> 
                  match lastId with
  