anchor.diff:      /// 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>
  +    abstract member LinkUp : Parser<'up, 'u> -> PipeLink<'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
  +    abstract member IgnoreUp : Parser<'up, 'u> -> PipeLink<'inp, 'out, 'u>
  +
  +let private supplyInput (link : PipeLink<_, _, _>) inp = link.ToOutputParser inp
  +let private linkUp parser (link : PipeLink<_, _, _>) = link.LinkUp parser
  +let private ignoreUp parser (link : PipeLink<_, _, _>) = 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
  
positive.code: //         (pipe3 pa pb pc (fun a b c d e f g h -> final_result))
  //         (pipe5 pd pe pf pg ph (fun d e f g h parent -> parent d e f g h)) (|>)
  let rec private linkBeyond5<'a, 'b, 'f, 'u>
      (functionLink : IPipeLink<'a, 'b, 'u>)
      (parseRemaining : Parser<'b -> 'f, 'u>)
      : IPipeLink<'a, 'f, 'u> =
      { new IPipeLink<'a, 'f, 'u>() with
          member __.ToFunctionParser = pipe2 (functionLink.ToFunctionParser) parseRemaining (>>)
          member __.ToOutputParser f = pipe2 (functionLink.ToOutputParser f) parseRemaining (|>)
          member __.LinkUp up = linkBeyond5 (functionLink.LinkUp up) parseRemaining
  
negative.code: /// if given a value of type `'inp`. Practically speaking, `'inp` is typically
  /// a function combining the outputs of the captured parsers constituting this pipe section.
  [<AbstractClass>]
  type PipeLink<'inp, 'out, 'u>() =
      /// Convert to a `Parser<'inp -> 'out, 'u>`. This defers the
      /// requirement of an `'inp` value to after parsing, rather than
      /// before creating the parser.
  