code: def either(self):
          
          # Currently the pattern will not be equivalent, but more "narrow",
          # although good enough to reason about list arguments.
          if not hasattr(self, 'children'):
              return Either(Required(self))
          else:
              ret = []
              groups = [[self]]
              while groups:
                  children = groups.pop(0)
                  types = [type(c) for c in children]
                  if Either in types:
                      either = [c for c in children if type(c) is Either][0]
                      children.pop(children.index(either))
                      for c in either.children:
                          groups.append([c] + children)
                  elif Required in types:
                      required = [c for c in children if type(c) is Required][0]
                      children.pop(children.index(required))
                      groups.append(list(required.children) + children)
                  elif Optional in types:
                      optional = [c for c in children if type(c) is Optional][0]
                      children.pop(children.index(optional))
                      groups.append(list(optional.children) + children)
                  elif OneOrMore in types:
                      oneormore = [c for c in children if type(c) is OneOrMore][0]
                      children.pop(children.index(oneormore))
                      groups.append(list(oneormore.children) * 2 + children)
                  else:
                      ret.append(children)
              return Either(*[Required(*e) for e in ret])
docs: Transform pattern into an equivalent, with only top-level Either.