anchor.diff:      let! q2 = character '\"'
       return s
     }
  -
  +(*
  +    Creates a Parser satisfying the input ( in EBNF ):
  +
  +    tab ::= '\t'
  +*)
   let tab() = 
     p{
       let! t = (character '\t') + (word "  ")
       return ()
     }
  -
  +(*
  +    Helper function to see if the input buffer is empty.
  +    If the input buffer is empty the end of the file has been reached.
  +*)
   let eof() =
     (fun buf ctxt pos ->
        match buf with
        | [] -> [(),[],ctxt,pos],[]
        | _ -> [],[Error pos]) |> Parser.Make
  -
  +(*
  +    Helper function to check for a valid new line.
  +*)
   let newline() = word "\r\n" + word "\n\r" + character '\n'
  -
  +(*
  +    The function blanc_space creates a new Parser matcing all whitespaces of the form of ' '.
  +*)
   let blank_space() = takeWhile (character ' ')
   
   let empty_line() = 
  
positive.code: (*
    Parser monad. The parser monad is responsible for the (lazy) chaining of the parsing operations.
    The chaining happens with the methods Bind and Combine. Bind takes as input one parser which performs
    the first parsing step...
  *)
  and ParserBuilder() =
    member this.Bind(p:Parser<'a,'ctxt>, k:'a->Parser<'b,'ctxt>) : Parser<'b,'ctxt> =
     (fun buf ctxt pos ->
        let all_res,err = p.Parse buf ctxt pos
  
negative.code:           yield k.Parse restBuf ctxt' pos'
          ]
        out |> List.map fst |> List.concat, err @ (out |> List.map snd |> List.concat)) |> Parser.Make
    (*
      The function Return creates a new Parser from any type 'a.
    *)
    member this.Return(x:'a) : Parser<'a,'ctxt> =
      (fun buf ctxt pos -> [x,buf,ctxt,pos],[]) |> Parser.Make
    member this.ReturnFrom(x:Parser<'a,'ctxt>) : Parser<'a,'ctxt> = x
  