anchor.diff:      }
   
   let link0 () =
  -    { new IPipeLink<_, _, _>() with
  +    { new PipeLink<_, _, _>() with
           member __.ToFunctionParser = preturn id
           member __.ToOutputParser f = preturn f
           member __.LinkUp up = link1 up
  
positive.code:     /// a function going from the preceding parser's output to our `'inp`.
      /// This lets us build an `IPipeLink` requiring an `a -> b -> c -> d`
      /// from a chain of `parseA`, `parseB`, `parseC`, working right-to-left.
      abstract member LinkUp : Parser<'up, 'u> -> IPipeLink<'up -> 'inp, 'out, 'u>
      /// Produce an `IPipeLink` that will run the given parser prior to this one's
      /// and ignore its output.
      abstract member IgnoreUp : Parser<'up, 'u> -> IPipeLink<'inp, 'out, 'u>
  
  let private supplyInput (link : IPipeLink<_, _, _>) inp = link.ToOutputParser inp
  let private linkUp parser (link : IPipeLink<_, _, _>) = link.LinkUp parser
  let private ignoreUp parser (link : IPipeLink<_, _, _>) = link.IgnoreUp parser
  
  // This combines parsers with more than 5 arguments.
  // The trick is to start a new link chain from 1 on the left side, and on the right side keep a parser
  
negative.code:     }
  
  and private link3 a b c =
      { new PipeLink<_, _, _>() with
          member __.ToFunctionParser = pipe3 a b c (fun a b c f -> f a b c)
          member __.ToOutputParser f = pipe3 a b c f
          member __.LinkUp up = link4 up a b c
  