anchor.diff:      [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{
  
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:     }
    word(s |> Seq.toList)
  
  (*
      The function takeWhile(s:Parser) will consume characters from a Parser's input buffer as long as the given Parser s is matched.
      This function will return either nothing or something. Nothing will be returned if a match was never found. Something will be returned if atleast one match was found.
      An example of this would be to match all characters 's'
  
      p {
          let! c = takeWhile (character 's')
          return c
      }
  
      "ss33s" -> 'ss'
      "fooss" -> ''
      
      This function allows functions like word and character to be applied 'zero or more times'.
      The amount of input consumed by this function depends on the amount of input the given parser s's Parse function consumes.
  *)
  
  let rec takeWhile (s:Parser<'a,'ctxt>) : Parser<List<'a>, 'ctxt> =
    p{
      let something = 
  