anchor.diff:      | 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
  
positive.code:   member this.Delay(f:unit -> Parser<'a,'ctxt>) = f()
    member this.Run(f:Parser<'a,'ctxt>) = f
  
  
  let parser = ParserBuilder()
  let p = parser  
  
  let fail() = 
    (fun _ _ pos -> [],[Error pos]) |> Parser.Make 
  
  let character(c:char) : Parser<char, 'ctxt> = 
   (fun buf ctxt (pos:Position) ->
    match buf with
  
negative.code:     [c, cs, ctxt, pos'],[]
    | _ -> [],[Error pos]) |> Parser.Make
  
  (*
      The function word(s) will test if the given string s's characters match the next characters found in a Parser's input buffer.
      This function will return a Parser with an error if either:
      - The input buffer is empty
      - The next character in the given string s is not equal to the next character in the Parser's input buffer.
      
      p {
          let! w = word "foo"
          return w
      }
  
      "foo" -> w = 'foo'
      "bar" -> w = error
  
      If all characters in the string s are matched a Parser type will be returned yielding the matched string (note that this string will always be equal to the given string s).
      This function will consume s.Length characters from the Parser's input buffer if matched.
  *)
  let word (s:string) =
    let rec word (w:List<char>) : Parser<List<char>, 'ctxt> =
      p{
  