anchor.diff:  
   type Parser<'a, 'ctxt> = { Parse : List<char> -> 'ctxt -> Position -> List<'a * List<char> * 'ctxt * Position> * List<Error>}
     with
  +    (*
  +        The Make function is used to construct a new Parser Monad.
  +        This function accepts a function in the form of p:List<char> -> 'ctxt -> Position -> List<'a * List<char> * 'ctxt * Position> * List<Error> and assigns the Parser's Parse function to this value.
  +    *)
       static member Make(p:List<char> -> 'ctxt -> Position -> List<'a * List<char> * 'ctxt * Position> * List<Error>) : Parser<'a,'ctxt> = { Parse = p }
  +    (*
  +        The ++ function constructs an error monad with the given two Parsers p1 and p2.
  +        
  +        The Error Monad will try to match the first Parser ( p1 ), if this Parser was not able to match the buffer then the second Parser ( p2 ) will try to get matched.
  +        If neither matched an error is returned.
  +        If p1 matched, p1's result will be returned.
  +        if p2 matched, p2's result will be returned.        
  +    *)
       static member (++) (p1:Parser<'a,'ctxt>, p2:Parser<'a,'ctxt>) : Parser<'a,'ctxt> = 
        (fun buf ctxt p ->
           match p1.Parse buf ctxt p with
  
positive.code:           yield (k res).Parse restBuf ctxt' pos'
          ]
        out |> List.map fst |> List.concat, err @ (out |> List.map snd |> List.concat)) |> Parser.Make
    member this.Combine(p:Parser<'a,'ctxt>, k:Parser<'b,'ctxt>) : Parser<'b,'ctxt> =
     (fun buf ctxt pos ->
        let all_res,err = p.Parse buf ctxt pos
  
negative.code:       [ for res,resBuf,ctxt',pos' in all_res -> c::res,resBuf,ctxt',pos' ],err
      | buf -> [[],buf,ctxt,pos],[]) |> Parser.Make
  
  (*
      Simple helper function to determine whether the given character c is in range of the codepoints of '0' and '9'.
  *)
  let isDigit c = c >= '0' && c <= '9'
  (*
      Simple helper function to determine whether the given character c is in range of the codepoints of 'A' and 'Z' and 'a' and 'z'.
  *)
  let isAlpha c = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
  
  (*
      Creates a Parser satisfying the input ( in EBNF ):
  
      digit ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  
      int_literal ::= ['-'] digit {digit}
  *)
  let intLiteral() = 
    p{
      let! sign = character '-' + p{ return () }
  