git.reasoningtechnology.com Git - SubU/blob

   1 # results.py
   2 from collections.abc import MutableMapping, Mapping, MutableSequence, Iterator
   3 import pprint
   4 from weakref import ref as wkref
   5 from typing import Tuple, Any
   6
   7 str_type: Tuple[type, ...] = (str, bytes)
   8 _generator_type = type((_ for _ in ()))
   9
  10
  11 class _ParseResultsWithOffset:
  12     __slots__ = ["tup"]
  13
  14     def __init__(self, p1, p2):
  15         self.tup = (p1, p2)
  16
  17     def __getitem__(self, i):
  18         return self.tup[i]
  19
  20     def __getstate__(self):
  21         return self.tup
  22
  23     def __setstate__(self, *args):
  24         self.tup = args[0]
  25
  26
  27 class ParseResults:
  28     """Structured parse results, to provide multiple means of access to
  29     the parsed data:
  30
  31     - as a list (``len(results)``)
  32     - by list index (``results[0], results[1]``, etc.)
  33     - by attribute (``results.<results_name>`` - see :class:`ParserElement.set_results_name`)
  34
  35     Example::
  36
  37         integer = Word(nums)
  38         date_str = (integer.set_results_name("year") + '/'
  39                     + integer.set_results_name("month") + '/'
  40                     + integer.set_results_name("day"))
  41         # equivalent form:
  42         # date_str = (integer("year") + '/'
  43         #             + integer("month") + '/'
  44         #             + integer("day"))
  45
  46         # parse_string returns a ParseResults object
  47         result = date_str.parse_string("1999/12/31")
  48
  49         def test(s, fn=repr):
  50             print("{} -> {}".format(s, fn(eval(s))))
  51         test("list(result)")
  52         test("result[0]")
  53         test("result['month']")
  54         test("result.day")
  55         test("'month' in result")
  56         test("'minutes' in result")
  57         test("result.dump()", str)
  58
  59     prints::
  60
  61         list(result) -> ['1999', '/', '12', '/', '31']
  62         result[0] -> '1999'
  63         result['month'] -> '12'
  64         result.day -> '31'
  65         'month' in result -> True
  66         'minutes' in result -> False
  67         result.dump() -> ['1999', '/', '12', '/', '31']
  68         - day: '31'
  69         - month: '12'
  70         - year: '1999'
  71     """
  72
  73     _null_values: Tuple[Any, ...] = (None, [], "", ())
  74
  75     __slots__ = [
  76         "_name",
  77         "_parent",
  78         "_all_names",
  79         "_modal",
  80         "_toklist",
  81         "_tokdict",
  82         "__weakref__",
  83     ]
  84
  85     class List(list):
  86         """
  87         Simple wrapper class to distinguish parsed list results that should be preserved
  88         as actual Python lists, instead of being converted to :class:`ParseResults`:
  89
  90             LBRACK, RBRACK = map(pp.Suppress, "[]")
  91             element = pp.Forward()
  92             item = ppc.integer
  93             element_list = LBRACK + pp.delimited_list(element) + RBRACK
  94
  95             # add parse actions to convert from ParseResults to actual Python collection types
  96             def as_python_list(t):
  97                 return pp.ParseResults.List(t.as_list())
  98             element_list.add_parse_action(as_python_list)
  99
 100             element <<= item | element_list
 101
 102             element.run_tests('''
 103                 100
 104                 [2,3,4]
 105                 [[2, 1],3,4]
 106                 [(2, 1),3,4]
 107                 (2,3,4)
 108                 ''', post_parse=lambda s, r: (r[0], type(r[0])))
 109
 110         prints:
 111
 112             100
 113             (100, <class 'int'>)
 114
 115             [2,3,4]
 116             ([2, 3, 4], <class 'list'>)
 117
 118             [[2, 1],3,4]
 119             ([[2, 1], 3, 4], <class 'list'>)
 120
 121         (Used internally by :class:`Group` when `aslist=True`.)
 122         """
 123
 124         def __new__(cls, contained=None):
 125             if contained is None:
 126                 contained = []
 127
 128             if not isinstance(contained, list):
 129                 raise TypeError(
 130                     "{} may only be constructed with a list,"
 131                     " not {}".format(cls.__name__, type(contained).__name__)
 132                 )
 133
 134             return list.__new__(cls)
 135
 136     def __new__(cls, toklist=None, name=None, **kwargs):
 137         if isinstance(toklist, ParseResults):
 138             return toklist
 139         self = object.__new__(cls)
 140         self._name = None
 141         self._parent = None
 142         self._all_names = set()
 143
 144         if toklist is None:
 145             self._toklist = []
 146         elif isinstance(toklist, (list, _generator_type)):
 147             self._toklist = (
 148                 [toklist[:]]
 149                 if isinstance(toklist, ParseResults.List)
 150                 else list(toklist)
 151             )
 152         else:
 153             self._toklist = [toklist]
 154         self._tokdict = dict()
 155         return self
 156
 157     # Performance tuning: we construct a *lot* of these, so keep this
 158     # constructor as small and fast as possible
 159     def __init__(
 160         self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance
 161     ):
 162         self._modal = modal
 163         if name is not None and name != "":
 164             if isinstance(name, int):
 165                 name = str(name)
 166             if not modal:
 167                 self._all_names = {name}
 168             self._name = name
 169             if toklist not in self._null_values:
 170                 if isinstance(toklist, (str_type, type)):
 171                     toklist = [toklist]
 172                 if asList:
 173                     if isinstance(toklist, ParseResults):
 174                         self[name] = _ParseResultsWithOffset(
 175                             ParseResults(toklist._toklist), 0
 176                         )
 177                     else:
 178                         self[name] = _ParseResultsWithOffset(
 179                             ParseResults(toklist[0]), 0
 180                         )
 181                     self[name]._name = name
 182                 else:
 183                     try:
 184                         self[name] = toklist[0]
 185                     except (KeyError, TypeError, IndexError):
 186                         if toklist is not self:
 187                             self[name] = toklist
 188                         else:
 189                             self._name = name
 190
 191     def __getitem__(self, i):
 192         if isinstance(i, (int, slice)):
 193             return self._toklist[i]
 194         else:
 195             if i not in self._all_names:
 196                 return self._tokdict[i][-1][0]
 197             else:
 198                 return ParseResults([v[0] for v in self._tokdict[i]])
 199
 200     def __setitem__(self, k, v, isinstance=isinstance):
 201         if isinstance(v, _ParseResultsWithOffset):
 202             self._tokdict[k] = self._tokdict.get(k, list()) + [v]
 203             sub = v[0]
 204         elif isinstance(k, (int, slice)):
 205             self._toklist[k] = v
 206             sub = v
 207         else:
 208             self._tokdict[k] = self._tokdict.get(k, list()) + [
 209                 _ParseResultsWithOffset(v, 0)
 210             ]
 211             sub = v
 212         if isinstance(sub, ParseResults):
 213             sub._parent = wkref(self)
 214
 215     def __delitem__(self, i):
 216         if isinstance(i, (int, slice)):
 217             mylen = len(self._toklist)
 218             del self._toklist[i]
 219
 220             # convert int to slice
 221             if isinstance(i, int):
 222                 if i < 0:
 223                     i += mylen
 224                 i = slice(i, i + 1)
 225             # get removed indices
 226             removed = list(range(*i.indices(mylen)))
 227             removed.reverse()
 228             # fixup indices in token dictionary
 229             for name, occurrences in self._tokdict.items():
 230                 for j in removed:
 231                     for k, (value, position) in enumerate(occurrences):
 232                         occurrences[k] = _ParseResultsWithOffset(
 233                             value, position - (position > j)
 234                         )
 235         else:
 236             del self._tokdict[i]
 237
 238     def __contains__(self, k) -> bool:
 239         return k in self._tokdict
 240
 241     def __len__(self) -> int:
 242         return len(self._toklist)
 243
 244     def __bool__(self) -> bool:
 245         return not not (self._toklist or self._tokdict)
 246
 247     def __iter__(self) -> Iterator:
 248         return iter(self._toklist)
 249
 250     def __reversed__(self) -> Iterator:
 251         return iter(self._toklist[::-1])
 252
 253     def keys(self):
 254         return iter(self._tokdict)
 255
 256     def values(self):
 257         return (self[k] for k in self.keys())
 258
 259     def items(self):
 260         return ((k, self[k]) for k in self.keys())
 261
 262     def haskeys(self) -> bool:
 263         """
 264         Since ``keys()`` returns an iterator, this method is helpful in bypassing
 265         code that looks for the existence of any defined results names."""
 266         return bool(self._tokdict)
 267
 268     def pop(self, *args, **kwargs):
 269         """
 270         Removes and returns item at specified index (default= ``last``).
 271         Supports both ``list`` and ``dict`` semantics for ``pop()``. If
 272         passed no argument or an integer argument, it will use ``list``
 273         semantics and pop tokens from the list of parsed tokens. If passed
 274         a non-integer argument (most likely a string), it will use ``dict``
 275         semantics and pop the corresponding value from any defined results
 276         names. A second default return value argument is supported, just as in
 277         ``dict.pop()``.
 278
 279         Example::
 280
 281             numlist = Word(nums)[...]
 282             print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
 283
 284             def remove_first(tokens):
 285                 tokens.pop(0)
 286             numlist.add_parse_action(remove_first)
 287             print(numlist.parse_string("0 123 321")) # -> ['123', '321']
 288
 289             label = Word(alphas)
 290             patt = label("LABEL") + Word(nums)[1, ...]
 291             print(patt.parse_string("AAB 123 321").dump())
 292
 293             # Use pop() in a parse action to remove named result (note that corresponding value is not
 294             # removed from list form of results)
 295             def remove_LABEL(tokens):
 296                 tokens.pop("LABEL")
 297                 return tokens
 298             patt.add_parse_action(remove_LABEL)
 299             print(patt.parse_string("AAB 123 321").dump())
 300
 301         prints::
 302
 303             ['AAB', '123', '321']
 304             - LABEL: 'AAB'
 305
 306             ['AAB', '123', '321']
 307         """
 308         if not args:
 309             args = [-1]
 310         for k, v in kwargs.items():
 311             if k == "default":
 312                 args = (args[0], v)
 313             else:
 314                 raise TypeError(
 315                     "pop() got an unexpected keyword argument {!r}".format(k)
 316                 )
 317         if isinstance(args[0], int) or len(args) == 1 or args[0] in self:
 318             index = args[0]
 319             ret = self[index]
 320             del self[index]
 321             return ret
 322         else:
 323             defaultvalue = args[1]
 324             return defaultvalue
 325
 326     def get(self, key, default_value=None):
 327         """
 328         Returns named result matching the given key, or if there is no
 329         such name, then returns the given ``default_value`` or ``None`` if no
 330         ``default_value`` is specified.
 331
 332         Similar to ``dict.get()``.
 333
 334         Example::
 335
 336             integer = Word(nums)
 337             date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
 338
 339             result = date_str.parse_string("1999/12/31")
 340             print(result.get("year")) # -> '1999'
 341             print(result.get("hour", "not specified")) # -> 'not specified'
 342             print(result.get("hour")) # -> None
 343         """
 344         if key in self:
 345             return self[key]
 346         else:
 347             return default_value
 348
 349     def insert(self, index, ins_string):
 350         """
 351         Inserts new element at location index in the list of parsed tokens.
 352
 353         Similar to ``list.insert()``.
 354
 355         Example::
 356
 357             numlist = Word(nums)[...]
 358             print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
 359
 360             # use a parse action to insert the parse location in the front of the parsed results
 361             def insert_locn(locn, tokens):
 362                 tokens.insert(0, locn)
 363             numlist.add_parse_action(insert_locn)
 364             print(numlist.parse_string("0 123 321")) # -> [0, '0', '123', '321']
 365         """
 366         self._toklist.insert(index, ins_string)
 367         # fixup indices in token dictionary
 368         for name, occurrences in self._tokdict.items():
 369             for k, (value, position) in enumerate(occurrences):
 370                 occurrences[k] = _ParseResultsWithOffset(
 371                     value, position + (position > index)
 372                 )
 373
 374     def append(self, item):
 375         """
 376         Add single element to end of ``ParseResults`` list of elements.
 377
 378         Example::
 379
 380             numlist = Word(nums)[...]
 381             print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321']
 382
 383             # use a parse action to compute the sum of the parsed integers, and add it to the end
 384             def append_sum(tokens):
 385                 tokens.append(sum(map(int, tokens)))
 386             numlist.add_parse_action(append_sum)
 387             print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321', 444]
 388         """
 389         self._toklist.append(item)
 390
 391     def extend(self, itemseq):
 392         """
 393         Add sequence of elements to end of ``ParseResults`` list of elements.
 394
 395         Example::
 396
 397             patt = Word(alphas)[1, ...]
 398
 399             # use a parse action to append the reverse of the matched strings, to make a palindrome
 400             def make_palindrome(tokens):
 401                 tokens.extend(reversed([t[::-1] for t in tokens]))
 402                 return ''.join(tokens)
 403             patt.add_parse_action(make_palindrome)
 404             print(patt.parse_string("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl'
 405         """
 406         if isinstance(itemseq, ParseResults):
 407             self.__iadd__(itemseq)
 408         else:
 409             self._toklist.extend(itemseq)
 410
 411     def clear(self):
 412         """
 413         Clear all elements and results names.
 414         """
 415         del self._toklist[:]
 416         self._tokdict.clear()
 417
 418     def __getattr__(self, name):
 419         try:
 420             return self[name]
 421         except KeyError:
 422             if name.startswith("__"):
 423                 raise AttributeError(name)
 424             return ""
 425
 426     def __add__(self, other) -> "ParseResults":
 427         ret = self.copy()
 428         ret += other
 429         return ret
 430
 431     def __iadd__(self, other) -> "ParseResults":
 432         if other._tokdict:
 433             offset = len(self._toklist)
 434             addoffset = lambda a: offset if a < 0 else a + offset
 435             otheritems = other._tokdict.items()
 436             otherdictitems = [
 437                 (k, _ParseResultsWithOffset(v[0], addoffset(v[1])))
 438                 for k, vlist in otheritems
 439                 for v in vlist
 440             ]
 441             for k, v in otherdictitems:
 442                 self[k] = v
 443                 if isinstance(v[0], ParseResults):
 444                     v[0]._parent = wkref(self)
 445
 446         self._toklist += other._toklist
 447         self._all_names |= other._all_names
 448         return self
 449
 450     def __radd__(self, other) -> "ParseResults":
 451         if isinstance(other, int) and other == 0:
 452             # useful for merging many ParseResults using sum() builtin
 453             return self.copy()
 454         else:
 455             # this may raise a TypeError - so be it
 456             return other + self
 457
 458     def __repr__(self) -> str:
 459         return "{}({!r}, {})".format(type(self).__name__, self._toklist, self.as_dict())
 460
 461     def __str__(self) -> str:
 462         return (
 463             "["
 464             + ", ".join(
 465                 [
 466                     str(i) if isinstance(i, ParseResults) else repr(i)
 467                     for i in self._toklist
 468                 ]
 469             )
 470             + "]"
 471         )
 472
 473     def _asStringList(self, sep=""):
 474         out = []
 475         for item in self._toklist:
 476             if out and sep:
 477                 out.append(sep)
 478             if isinstance(item, ParseResults):
 479                 out += item._asStringList()
 480             else:
 481                 out.append(str(item))
 482         return out
 483
 484     def as_list(self) -> list:
 485         """
 486         Returns the parse results as a nested list of matching tokens, all converted to strings.
 487
 488         Example::
 489
 490             patt = Word(alphas)[1, ...]
 491             result = patt.parse_string("sldkj lsdkj sldkj")
 492             # even though the result prints in string-like form, it is actually a pyparsing ParseResults
 493             print(type(result), result) # -> <class 'pyparsing.ParseResults'> ['sldkj', 'lsdkj', 'sldkj']
 494
 495             # Use as_list() to create an actual list
 496             result_list = result.as_list()
 497             print(type(result_list), result_list) # -> <class 'list'> ['sldkj', 'lsdkj', 'sldkj']
 498         """
 499         return [
 500             res.as_list() if isinstance(res, ParseResults) else res
 501             for res in self._toklist
 502         ]
 503
 504     def as_dict(self) -> dict:
 505         """
 506         Returns the named parse results as a nested dictionary.
 507
 508         Example::
 509
 510             integer = Word(nums)
 511             date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
 512
 513             result = date_str.parse_string('12/31/1999')
 514             print(type(result), repr(result)) # -> <class 'pyparsing.ParseResults'> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]})
 515
 516             result_dict = result.as_dict()
 517             print(type(result_dict), repr(result_dict)) # -> <class 'dict'> {'day': '1999', 'year': '12', 'month': '31'}
 518
 519             # even though a ParseResults supports dict-like access, sometime you just need to have a dict
 520             import json
 521             print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable
 522             print(json.dumps(result.as_dict())) # -> {"month": "31", "day": "1999", "year": "12"}
 523         """
 524
 525         def to_item(obj):
 526             if isinstance(obj, ParseResults):
 527                 return obj.as_dict() if obj.haskeys() else [to_item(v) for v in obj]
 528             else:
 529                 return obj
 530
 531         return dict((k, to_item(v)) for k, v in self.items())
 532
 533     def copy(self) -> "ParseResults":
 534         """
 535         Returns a new copy of a :class:`ParseResults` object.
 536         """
 537         ret = ParseResults(self._toklist)
 538         ret._tokdict = self._tokdict.copy()
 539         ret._parent = self._parent
 540         ret._all_names |= self._all_names
 541         ret._name = self._name
 542         return ret
 543
 544     def get_name(self):
 545         r"""
 546         Returns the results name for this token expression. Useful when several
 547         different expressions might match at a particular location.
 548
 549         Example::
 550
 551             integer = Word(nums)
 552             ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d")
 553             house_number_expr = Suppress('#') + Word(nums, alphanums)
 554             user_data = (Group(house_number_expr)("house_number")
 555                         | Group(ssn_expr)("ssn")
 556                         | Group(integer)("age"))
 557             user_info = user_data[1, ...]
 558
 559             result = user_info.parse_string("22 111-22-3333 #221B")
 560             for item in result:
 561                 print(item.get_name(), ':', item[0])
 562
 563         prints::
 564
 565             age : 22
 566             ssn : 111-22-3333
 567             house_number : 221B
 568         """
 569         if self._name:
 570             return self._name
 571         elif self._parent:
 572             par = self._parent()
 573
 574             def find_in_parent(sub):
 575                 return next(
 576                     (
 577                         k
 578                         for k, vlist in par._tokdict.items()
 579                         for v, loc in vlist
 580                         if sub is v
 581                     ),
 582                     None,
 583                 )
 584
 585             return find_in_parent(self) if par else None
 586         elif (
 587             len(self) == 1
 588             and len(self._tokdict) == 1
 589             and next(iter(self._tokdict.values()))[0][1] in (0, -1)
 590         ):
 591             return next(iter(self._tokdict.keys()))
 592         else:
 593             return None
 594
 595     def dump(self, indent="", full=True, include_list=True, _depth=0) -> str:
 596         """
 597         Diagnostic method for listing out the contents of
 598         a :class:`ParseResults`. Accepts an optional ``indent`` argument so
 599         that this string can be embedded in a nested display of other data.
 600
 601         Example::
 602
 603             integer = Word(nums)
 604             date_str = integer("year") + '/' + integer("month") + '/' + integer("day")
 605
 606             result = date_str.parse_string('1999/12/31')
 607             print(result.dump())
 608
 609         prints::
 610
 611             ['1999', '/', '12', '/', '31']
 612             - day: '31'
 613             - month: '12'
 614             - year: '1999'
 615         """
 616         out = []
 617         NL = "\n"
 618         out.append(indent + str(self.as_list()) if include_list else "")
 619
 620         if full:
 621             if self.haskeys():
 622                 items = sorted((str(k), v) for k, v in self.items())
 623                 for k, v in items:
 624                     if out:
 625                         out.append(NL)
 626                     out.append("{}{}- {}: ".format(indent, ("  " * _depth), k))
 627                     if isinstance(v, ParseResults):
 628                         if v:
 629                             out.append(
 630                                 v.dump(
 631                                     indent=indent,
 632                                     full=full,
 633                                     include_list=include_list,
 634                                     _depth=_depth + 1,
 635                                 )
 636                             )
 637                         else:
 638                             out.append(str(v))
 639                     else:
 640                         out.append(repr(v))
 641             if any(isinstance(vv, ParseResults) for vv in self):
 642                 v = self
 643                 for i, vv in enumerate(v):
 644                     if isinstance(vv, ParseResults):
 645                         out.append(
 646                             "\n{}{}[{}]:\n{}{}{}".format(
 647                                 indent,
 648                                 ("  " * (_depth)),
 649                                 i,
 650                                 indent,
 651                                 ("  " * (_depth + 1)),
 652                                 vv.dump(
 653                                     indent=indent,
 654                                     full=full,
 655                                     include_list=include_list,
 656                                     _depth=_depth + 1,
 657                                 ),
 658                             )
 659                         )
 660                     else:
 661                         out.append(
 662                             "\n%s%s[%d]:\n%s%s%s"
 663                             % (
 664                                 indent,
 665                                 ("  " * (_depth)),
 666                                 i,
 667                                 indent,
 668                                 ("  " * (_depth + 1)),
 669                                 str(vv),
 670                             )
 671                         )
 672
 673         return "".join(out)
 674
 675     def pprint(self, *args, **kwargs):
 676         """
 677         Pretty-printer for parsed results as a list, using the
 678         `pprint <https://docs.python.org/3/library/pprint.html>`_ module.
 679         Accepts additional positional or keyword args as defined for
 680         `pprint.pprint <https://docs.python.org/3/library/pprint.html#pprint.pprint>`_ .
 681
 682         Example::
 683
 684             ident = Word(alphas, alphanums)
 685             num = Word(nums)
 686             func = Forward()
 687             term = ident | num | Group('(' + func + ')')
 688             func <<= ident + Group(Optional(delimited_list(term)))
 689             result = func.parse_string("fna a,b,(fnb c,d,200),100")
 690             result.pprint(width=40)
 691
 692         prints::
 693
 694             ['fna',
 695              ['a',
 696               'b',
 697               ['(', 'fnb', ['c', 'd', '200'], ')'],
 698               '100']]
 699         """
 700         pprint.pprint(self.as_list(), *args, **kwargs)
 701
 702     # add support for pickle protocol
 703     def __getstate__(self):
 704         return (
 705             self._toklist,
 706             (
 707                 self._tokdict.copy(),
 708                 self._parent is not None and self._parent() or None,
 709                 self._all_names,
 710                 self._name,
 711             ),
 712         )
 713
 714     def __setstate__(self, state):
 715         self._toklist, (self._tokdict, par, inAccumNames, self._name) = state
 716         self._all_names = set(inAccumNames)
 717         if par is not None:
 718             self._parent = wkref(par)
 719         else:
 720             self._parent = None
 721
 722     def __getnewargs__(self):
 723         return self._toklist, self._name
 724
 725     def __dir__(self):
 726         return dir(type(self)) + list(self.keys())
 727
 728     @classmethod
 729     def from_dict(cls, other, name=None) -> "ParseResults":
 730         """
 731         Helper classmethod to construct a ``ParseResults`` from a ``dict``, preserving the
 732         name-value relations as results names. If an optional ``name`` argument is
 733         given, a nested ``ParseResults`` will be returned.
 734         """
 735
 736         def is_iterable(obj):
 737             try:
 738                 iter(obj)
 739             except Exception:
 740                 return False
 741             else:
 742                 return not isinstance(obj, str_type)
 743
 744         ret = cls([])
 745         for k, v in other.items():
 746             if isinstance(v, Mapping):
 747                 ret += cls.from_dict(v, name=k)
 748             else:
 749                 ret += cls([v], name=k, asList=is_iterable(v))
 750         if name is not None:
 751             ret = cls([ret], name=name)
 752         return ret
 753
 754     asList = as_list
 755     asDict = as_dict
 756     getName = get_name
 757
 758
 759 MutableMapping.register(ParseResults)
 760 MutableSequence.register(ParseResults)