anchor.diff:      | "disable" -> Some Disabled
       | _ -> None
   
  -  let (|OptionSetting|_|) (name: string) (lens: Lens<_, _>) opt (str: string) =
  +  let (|OptionSetting|_|) (name: string) (lens: Lens<_, _>) target (str: string) =
       match str.Split([| ' ' |], 2) with
       | [| key; value |] when key = name ->
         match tryParseOptionStatus value with
  -      | Some value -> Some (lens.Set value opt)
  -      | None -> printfn "invalid value"; Some opt
  +      | Some value -> Some (lens.Set value target)
  +      | None -> printfn "invalid value"; Some target
       | [| key |] when key = name ->
  -      printfn "%A" (lens.Get opt)
  -      Some opt
  +      printfn "%A" (lens.Get target)
  +      Some target
       | _ -> None
   
     let StrictQueryVariable = { Get = (fun x -> x.StrictQueryVariable ); Set = (fun value x -> { x with StrictQueryVariable = value }) }
     let SimilaritySearching = { Get = (fun x -> x.SimilaritySearching ); Set = (fun value x -> { x with SimilaritySearching = value }) }
  +  let StackTrace = { Get = (fun x -> x.StackTrace); Set = (fun value x -> { x with StackTrace = value }) }
   
     let rec loop (client: FSharpApiSearchClient) arg =
       printf "> "
  
positive.code:     | Status "--similarity" v :: rest -> parse { arg with SearchOptions = { arg.SearchOptions with SimilaritySearching = boolToOptionStatus v } } rest
      | (KeyValue "--target" t | KeyValue "-t" t) :: rest -> parse { arg with Targets = t :: arg.Targets } rest
      | (KeyValue "--reference" r | KeyValue "-r" r) :: rest -> parse { arg with References = r :: arg.References } rest
      | Status "--stacktrace" v :: rest -> parse { arg with StackTrace = v } rest
      | ("--help" | "-h") :: rest -> parse { arg with Help = true } rest
      | query :: rest ->
        let q =
  
negative.code:     | "#q" -> arg
      | OptionSetting "#strict" StrictQueryVariable arg.SearchOptions newOpt -> loop client { arg with SearchOptions = newOpt }
      | OptionSetting "#similarity" SimilaritySearching arg.SearchOptions newOpt -> loop client { arg with SearchOptions = newOpt }
      | OptionSetting "#stacktrace" StackTrace arg newArg -> loop client newArg
      | query ->
        try
          searchAndShowResult client query arg.SearchOptions
        with ex ->
          match arg.StackTrace with
          | Enabled -> printfn "%A" ex
          | Disabled -> printfn "%s" ex.Message
        loop client arg
  
  let helpMessage = """usage: FSharpApiSearch.Console.exe <query> <options>
  