anchor.diff:        }
   
       let json_react (evt : JsonEventBind) =
  -      let pat, e, def = evt 
  +      let pat, e = evt
         POST
         >=>
         contentType "application/json"
  
positive.code:             let txt = System.Text.Encoding.ASCII.GetString(h.request.rawForm)
              try 
                let o = JToken.Parse(txt)
                let evt = JsonEventArgs(h, o, pat, m, def)
                async { e.Trigger(evt) } |> Async.Start |> ignore
                return! evt.Result h
              with _ -> return None
  
negative.code:         member this.Match = m
          member this.Result with get()  = waitHandle.WaitOne() |> ignore
                                           waitHandle.Dispose()
                                           match result with
                                           | None -> Suave.ServerErrors.INTERNAL_ERROR "Inconsistent internal state"
                                           | Some v -> v
  
                              and set(v) = match result with
                                           | None -> result <- Some v
                                           | Some _ -> failwith "Result already set"
                                           waitHandle.Set() |> ignore
  
      type JsonEventArgs (h:HttpContext, o:JToken, path:string, m:Match) =
          inherit HttpEventArgs(h, path, m)
  
          member this.Object = o
  
      type HttpEvent = EvReact.Event<HttpEventArgs>
      type JsonEvent = EvReact.Event<JsonEventArgs>
  
      type HttpEventBind = string*HttpEvent
      type JsonEventBind = string*JsonEvent
  
      let http_react (evt : HttpEventBind) =
        let pat, e = evt
        fun (h:HttpContext) ->
          let m = Regex.Match(h.request.url.AbsolutePath, pat)
          if m.Success then
            let evt = HttpEventArgs(h, pat, m)
            async { e.Trigger(evt) } |> Async.Start |> ignore
            evt.Result(h)
          else
  