anchor.diff:  
   (*| Punctuation Parsers |*)
   
  -let ``.``   : Parser<_> = pchar '.'
  -let ``,``   : Parser<_> = attempt (skip_tspcs >>. pchar ',' .>> skip_tspcs)  
  -
  -let ``[``   : Parser<_> = skip_tspcs >>. pchar '['    .>> skip_tspcs           
  -let ``]``   : Parser<_> = skip_tspcs >>. pchar ']'    .>> skip_tspcs
  -let ``{``   : Parser<_> = skip_tspcs >>. pchar '{'    .>> skip_tspcs
  -let ``}``   : Parser<_> = skip_tspcs >>. pchar '}'    .>> skip_tspcs 
  -let ``[[``  : Parser<_> = skip_tspcs >>. pstring "[[" .>> skip_tspcs  
  -let ``]]``  : Parser<_> = skip_tspcs >>. pstring "]]" .>> skip_tspcs  
  +
  +let ``.``   : Parser<_> = pchar '.' .>> skip_tspcs 
  +let ``,``   : Parser<_> = pchar ',' .>> skip_tspcs   
  +
  +let ``[``   : Parser<_> = pchar '[' .>> skip_tspcs              
  +let ``]``   : Parser<_> = pchar ']' .>> skip_tspcs   
  +let ``{``   : Parser<_> = pchar '{' .>> skip_tspcs   
  +let ``}``   : Parser<_> = pchar '}' .>> skip_tspcs    
  +let ``[[``  : Parser<_> = pstring "[[" .>> skip_tspcs  
  +let ``]]``  : Parser<_> = pstring "]]" .>> skip_tspcs  
   let ``"``   : Parser<_> = pchar '"'
   let ``'``   : Parser<_> = pchar '\''
   let ``"""`` : Parser<_> = pstring "\"\"\""
   let ``'''`` : Parser<_> = pstring "\'\'\'"
  -let skipEqs : Parser<_> = skip_tspcs >>. skipChar '=' >>. skip_tspcs
  +
  +let prevCharNot = previousCharSatisfiesNot
  +let ``|"|``   : Parser<_> = prevCharNot((=)'\\') >>. pchar '"'
  +let ``|'|``   : Parser<_> = prevCharNot((=)'\\') >>. pchar '\''
  +let ``|"""|`` : Parser<_> = prevCharNot((=)'\\') >>. pstring "\"\"\""
  +let ``|'''|`` : Parser<_> = prevCharNot((=)'\\') >>. pstring "\'\'\'"
  +let skipEqs   : Parser<_> = skipChar '=' >>. skip_tspcs
   
   
   (*| String Parsers |*)
   
  -let psingle_string    : Parser<_> = between ``"`` ``"`` (manySatisfy ((<>)'"'))
  -let pmult_string      : Parser<_> = between ``"""`` ``"""`` (manyChars anyChar)
  -let psingle_litstring : Parser<_> = between ``'`` ``'`` (manySatisfy ((<>)'\''))
  -let pmult_litstring   : Parser<_> = between ``'''`` ``'''`` (manyChars anyChar)
  +// TODO - fully implement string spec
  +// probably need to make a low level string parser
  +let psingle_string    : Parser<_> = 
  +    between ``|"|`` ``|"|`` 
  +        (manyChars ((previousCharSatisfies ((=)'\\')>>.``"``)<|> satisfy ((<>)'"'))) 
  +
  +let pmult_string      : Parser<_> = (between ``|"""|`` ``|"""|`` (manyChars anyChar) )
  +let psingle_litstring : Parser<_> = (between ``|'|`` ``|'|`` (manySatisfy ((<>)'\'')))
  +let pmult_litstring   : Parser<_> = (between ``|'''|`` ``|'''|`` (manyChars anyChar) )
   
   let toml_string : Parser<_> =
  -    choice [ psingle_string; pmult_string; psingle_litstring; pmult_litstring ]
  -    |>> Value.String
  +    (choice [ psingle_string; pmult_string; psingle_litstring; pmult_litstring ]
  +        |>> Value.String) .>> skip_tspcs
   
   
   (*| Numeric Parsers |*)
  
positive.code: /// Compose predicates with `||`
  let inline (|?|) (pred1:'a->bool) (pred2:'a->bool) = fun x -> pred1 x || pred2 x
  
  [<RequireQualifiedAccess>]
  module  List =
      let inline last ls =
  
negative.code:         Reply (Error, ErrorMessageList.Merge (expected "some kind of TOML value", reply.Error))
      | _ -> Reply (Error, expected "some kind of TOML value")
  
  pValueImpl := value_parser .>> skip_tspcs
  
          
  (*| Toplevel Parsers |*)
  
  let toml_item : Parser<_> = toml_key .>>. (skipEqs >>. toml_value) .>> tskipRestOfLine
  
  let toml_toplevel, private pToplevelImpl = createParserForwardedToRef ()
  
  
  let pTable : Parser<_> =
      ((pTableKey .>> tskipRestOfLine) .>>. (many (toml_toplevel))
      |>> fun (ks,items) -> 
          let tk = List.last ks
          let tbl:(_,_) table = table<_,_> ()
          //List.iter (fun x -> printfn "%A" x) items
          List.iter (tbl.Add) items
          tk,Value.Table tbl )
          .>> choice[attempt skipUnicodeNewline; attempt skip_tspcs]
  //        Value.Table tbl )
  
  
  let pTableArray : Parser<_> =
      ((pTableArrayKey .>> tskipRestOfLine) .>>. (many toml_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)
      //    .>> skip_tspcs
      
  let inline print str x = printfn "%s%A" str x; x
  
  let private toplevel_parser (stream: CharStream<_>) =
      match stream.Peek () with
      | '#'  -> (skipComment >>. toml_toplevel .>> skip_tspcs) stream
      | ' '
      | '\t' -> (skip_tspcs >>. toml_toplevel .>> skip_tspcs) stream
      //| '\n' -> (skipUnicodeNewline >>. toml_toplevel .>> skip_tspcs) stream
      | '['  -> 
          if stream.Peek2() = TwoChars('[','[') then (pTableArray.>> skip_tspcs) stream else
          (pTable.>> skip_tspcs ) stream
      | c when (isDigit|?|isLetter|?|isAnyOf['"';'\'']) c ->
          (toml_item .>> skip_tspcs) stream
      | c    -> 
  //        printfn "failchar = %c" c
  //        printfn "Line - %d | Col - %d | Index - %d" 
  //            stream.Position.Line stream.Position.Column stream.Position.Index
          Reply (Error, expected "A TOML table, array of tables, or a key value pair")
  
  pToplevelImpl := 
     // (skip_tspcs >>. skipUnicodeNewline >>. skip_tspcs) 
     // >>. 
      toplevel_parser 
      //.>> skip_tspcs
  
  let parse_toml : Parser<_> = 
      (many1 (skip_tspcs >>. toml_toplevel .>> skip_tspcs)
      |>> fun items -> 
          let tbl:(_,_) table = table<_,_> ()
          List.iter tbl.Add items
          tbl) .>> (skipUnicodeNewline <|> skipToEOF)
  (* 
      ---- NOTES ----
      
  