anchor.diff:  
   
   (*| Punctuation Parsers |*)
  -
   
   let ``.``   : Parser<_> = pchar '.' .>> skip_tspcs 
   let ``,``   : Parser<_> = pchar ',' .>> skip_tspcs   
  
positive.code: let tspc       = toml_space
  let tspcs      = toml_spaces
  let skip_tspcs = skip_toml_spaces
      //choice [attempt (skip_toml_spaces .>> skipUnicodeNewline .>> skip_toml_spaces);
        //      skip_toml_spaces]
  let skipToEOF :Parser<_>= skipManyTill skipAnyChar eof
  
  (*| Comment/LineEnd Parsers |*)
  
  
negative.code: 
  let toplevel = choice [toml_item;toml_table;toml_tableArray]
  
  pTableImpl :=
      ((pTableKey .>> tskipRestOfLine) .>>. (many toplevel)
      |>> fun (ks,items) -> 
          let tk = List.last ks
          let tbl:(_,_) table = table<_,_> ()
          List.iter (tbl.Add) items
          tk,Value.Table tbl )
          .>> choice[attempt skipUnicodeNewline; attempt skip_tspcs]
  
  pTableArrayImpl :=
      (pTableArrayKey .>> tskipRestOfLine) .>>. (many toplevel)
      |>> fun (ks,tbls) -> 
          let ak = List.last ks
          let arr =
              tbls |> List.map (fun (key,value) -> 
              let tbl:(_,_) table = table<_,_> ()
              tbl.Add(key,value)
              tbl) 
          ak, Value.TableArray arr
      
  let inline private print str x = printfn "%s%A" str x; x
  
  let toml_parser (stream: CharStream<_>) =
      let mutable loopcount = 0
      let rec loop acc (stream: CharStream<_>) =
          loopcount <- loopcount + 1
          if loopcount > 20000 then printfn "looped %d times\nwas likely stuck in infinite loop" loopcount; acc else
          let inline checkReply (psr:Parser<_>) =
              let state, (reply:Reply<_>)  = stream.State, psr stream
              if reply.Status <> Ok then stream.BacktrackTo state; acc else
              (reply.Result::acc)
  
          match stream.Peek () with
          | '#'  -> stream.SkipRestOfLine true; loop acc stream
          | ' '
          | '\t' -> if not (stream.SkipUnicodeWhitespace ()) then acc else loop acc stream 
          | '['  -> 
              if stream.Peek2() = TwoChars('[','[') then 
                  loop (checkReply toml_tableArray) stream
              else loop (checkReply toml_table) stream
          | c when (isDigit|?|isLetter|?|isAnyOf['"';'\'']) c ->
              loop (checkReply toml_item) stream
          | '\n' -> if not (stream.SkipUnicodeNewline()) then acc else loop acc stream
          | _    -> 
              if stream.IsEndOfStream then printf "reached the end of stream" 
              acc
      Reply<_>(loop [] stream |> List.rev)
  
  //pTomlImpl :=  pToml 
  
  let parse_toml : Parser<_> = 
      toml_parser |>> fun items -> 
          let tbl:(_,_) table = table<_,_> ()
          List.iter (tbl.TryAdd>>ignore) items
          TOML tbl 
  
  (* 
      ---- NOTES ----
      
  