anchor.diff:      member this.Line = let (Error p) = this in p.Line
       static member Distinct (errors:List<Error>) = 
         errors |> Set.ofList |> Set.toSeq
  +      
  +(*
  +    A Parser consists of one function 'Parse', this function will return a tuple of a two lists.
  +    The first list contains a tuple of
  +    - A value of Type 'a. This value yields the result of applinyg 'Parse' to the buffer. This value will be referenced as the 'yielded value', if the parser 'yields a value' that value would be assigned to this value.
  +    - A list of characters. This list contains the remaining characters. The list can be seen as a buffer for uncomsumed input.
  +    - A context. The context is responsible for holding additional values needed during the parsing process. An example of this would be keywords with their appropriate names and values.
  +    - A Position. The position holds the current line index in the input buffer. The positions' line index is 'incremented' for every valid line break found during parsing.
  +    The second list is reponsible for keeping track of errors found during parsing. The list consists of the elements of type Position to track down the location of the error.
  +
  +    A Parser is constructed by calling Parser.Make (f), here f must be a function of type List<char> -> 'ctxt -> Position -> List<'a * List<char> * 'ctxt * Position> * List<Error>.
  +
  +    The Parser works by monadicly binding multiply Parsers to eachother. A simple example of a Parser trying to match a simple sequence of two characters 'i' and 'f' will look like this:
  +
  +    p {
  +        let! c = character 'i'
  +        let! c' = character 'f'
  +        return ()
  +    }
  +
  +    If character 'i' was satisfied then we will move on to the next expression ( It is also worth noting that the function character will consume one character from the input buffer ).
  +    If character 'i' was not satisfied ( or the input buffer was empty! ) then we would have not moved on to the next expression, the behaviour when a match can not be found is dependent on the function used.
  +    In this case, the function character will return the location of the error and return a Parser type containing this error.
  +    If character 'f' was satisfied then we will ParserBuilder.Return () this function will return a Parser with an empty yield and the remaining input buffer.
  +
  +    It is possible to create a complex parser in this manner. 
  +*)
  +
   
   type Parser<'a, 'ctxt> = { Parse : List<char> -> 'ctxt -> Position -> List<'a * List<char> * 'ctxt * Position> * List<Error>}
     with
  
positive.code:     | Second l -> return l
    }
  
  let rec character' (p:char -> bool) : Parser<char, 'ctxt> =
   (fun buf ctxt (pos:Position) ->
      match buf with
      | c::cs when p c -> [c, cs, ctxt, if c = '\n' then pos.NextLine else pos],[]
      | buf -> [],[Error pos]) |> Parser.Make
  
  let rec takeWhile' (p:char -> bool) : Parser<List<char>,'ctxt> =
   (fun buf ctxt pos ->
      match buf with
  
negative.code:   member this.Delay(f:unit -> Parser<'a,'ctxt>) = f()
    member this.Run(f:Parser<'a,'ctxt>) = f
  
  let parser = ParserBuilder()
  let p = parser  
  
  (*
    Utility function to easily create a Parser type containing an error at it's current location.  
  *)
  let fail() = 
    (fun _ _ pos -> [],[Error pos]) |> Parser.Make 
  
  (*
      The function character(c) will test if the next character in a Parser's input buffer matches the given character c.
      This function will return a Parser with an error if either:
      - The input buffer is empty
      - The given character c does not equal the first character in the Parser's input buffer
      
      p {
          let! c = character 't'
          return c
      }
  
      "test" -> c = 't'
      "foo3" -> error
  
      If the given character c matches the first character in the Parser's input buffer a Parser type will be returned containing the matched character c and the remaining buffer.
      Note that, if c is matched, this function will consume one character from the Parser's input buffer.
  *)
  let character(c:char) : Parser<char, 'ctxt> = 
   (fun buf ctxt (pos:Position) ->
    match buf with
  