anchor.diff:    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
  
positive.code:     [c, cs, ctxt, pos'],[]
    | _ -> [],[Error pos]) |> Parser.Make
  
  let word (s:string) =
    let rec word (w:List<char>) : Parser<List<char>, 'ctxt> =
      p{
  
negative.code:     | Second l -> return l
    }
  
  (*
      The function character'(p:char->bool) will test if the next character in a Parser's input satisfies ( p(c) will return true ) the given function p.
      This function will return a Parser with an error if either:
      - The input buffer is empty
      - The next character in the Parser's input buffer does not satisfy the given function p.
      
      p {
          let! c = character' isAlpha
          return c
      }
  
      "hello3" -> 'h'
      "1world" -> error
  
      If the next character in the Parser's input buffer does satisfy the given function p a Parser type will be returned containing the matched character and the remaining buffer.
      Note that, if p is satisfied, this function will consume one character from the Parser's input buffer.
  *)
  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
  
  (*
      The function takeWhile'(p:char->bool) will consume characters from a Parser's input buffer as long as the given function p is satisfied ( p(c) will return true ).
      This function will never return an error.
  
      This function will return all the characters from the Parser's input buffer as long as they satisfy the given function p, if p is not satisfied the process is stopped.
  
      An example of using this function would be to match all characters as long as they are digits, if a non-digit stop.
  
      p {
          let! c = takeWhile isDigit c
          return c
      }
  
      "123aade3" -> c = '123'
      "foo14443" -> c = ''
      
      This function allows functions like character' to be re-used 
      The amount of input consumed by this function is equal to the amount of times p was satisfied before the process was stopped.
  *)
  let rec takeWhile' (p:char -> bool) : Parser<List<char>,'ctxt> =
   (fun buf ctxt pos ->
      match buf with
  