anchor.diff:      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
  +        (f :> Object).Equals(tobj)
       override this.GetHashCode() = base.GetHashCode()
       
   and RSet<'a> = Set<GParserResult<'a> >
  
positive.code:     Saved: HOMap<GParserResult<'a>, FSet<'a> >
  
      Stopped: bool
      Successes: SSet<'a>
      Failures: SSet<'a>
      Postrace: string list
      DisRes: Map<TUid, SSet<'a> >
  } 
  and T () =
       
      static member AddResult<'a> (r: GParserResult<'a>) : PState<'a> = 
          getState >>= fun t ->
              putState <| if r.Succeeded then { t with Successes = t.Successes.Add(r) }
                                         else { t with Failures = t.Failures.Add(r) }
  
      static member Run<'a> () : PState<'a> = state { 
          let! t = getState
  
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>()
  