anchor.diff:          { 
               Queue = []; Done = Map.empty; Popped = Map.empty; DisRes = Map.empty
               Backlinks = Map.empty; Saved = Map.empty; Stopped = false
  -            Successes = Set.empty; Failures = Set.empty; Postrace = []
  +            Results = Set.empty; Postrace = []
           }
           |> 
           state {
               do! this.Chain(inp) (Continuation<_>.New(fun res ->
  -                if res.Succeeded && not res.Tail.IsEmpty 
  -                then failure "UnexpectedTrailingChars" (res.Tail) else res
  -                |> T.AddResult
  +                let r = if res.Succeeded && not res.Tail.IsEmpty 
  +                        then failure "UnexpectedTrailingChars" (res.Tail) else res
  +                modify <| fun t -> { t with Results = t.Results.Add(r) }
               ))
               do! T.Run ()
               let! t = getState
  -            return (if t.Successes.Count = 0 then t.Failures else t.Successes) |> Seq.toList
  +            let successes, failures = t.Results |> Seq.toList |> List.partition (fun r -> r.Succeeded) 
  +            return (if List.isEmpty successes then failures else successes)
           } 
           |> fst
           
  
positive.code:     member this.F : (GParserResult<'a> -> PState<'a>)  = f
      static member New fn = new Continuation<'a>(fn)
      override this.Equals that = 
          //Object.ReferenceEquals (f, (that :?> Continuation<'a>).F) |> ignore
          //let refeq = Object.ReferenceEquals (f, (that :?> Continuation<'a>).F)
          let tobj = (that :?> Continuation<'a>).F
          let eqeq = (f :> Object).Equals(tobj)
          eqeq
      override this.GetHashCode() = base.GetHashCode()
      
  and RSet<'a> = Set<GParserResult<'a> >
  
negative.code: 
      abstract member Parse : InputStream<'a> -> GParserResult<'a>
  
      override this.Chain (inp) (f) = this.Parse inp |> f.F
      override this.Apply (inp: InputStream<'a>) = 
              match this.Parse(inp) with 
              | :? GSuccess<'a, 'r> as succ1 -> [succ1]
              | x -> [x]
  
  and DisjunctiveParser<'a, 'r when 'r : equality>(left: Parser<'a, 'r>, right: Parser<'a, 'r>) as disj =
      inherit NonTerminalParser<'a, 'r>()
  