code: def merge_into(self, other):
          
          # TODO it shouldn't be possible to merge two elements or two pseudo
          # elements, /but/ it shouldn't just be a fatal error here -- it
          # shouldn't even be considered a candidate for extending!
          # TODO this is slightly inconsistent with ruby, which treats a trailing
          # set of self tokens like ':before.foo' as a single unit to be stuck at
          # the end.  but that's completely bogus anyway.
          element = []
          middle = []
          pseudo = []
          for token in self.tokens + other.tokens:
              if token in CSS2_PSEUDO_ELEMENTS or token.startswith('::'):
                  pseudo.append(token)
              elif token[0] in BODY_TOKEN_SIGILS:
                  middle.append(token)
              else:
                  element.append(token)
          new_tokens = element + middle + pseudo
  
          if self.combinator == ' ' or self.combinator == other.combinator:
              combinator = other.combinator
          elif other.combinator == ' ':
              combinator = self.combinator
          else:
              raise ValueError(
                  "Don't know how to merge conflicting combinators: "
                  "{0!r} and {1!r}"
                  .format(self, other))
          return type(self)(combinator, new_tokens)
docs: Merge two simple selectors together.  This is expected to be the
          selector being injected into `other` -- that is, `other` is the
          selector for a block using ``@extend``, and `self` is a selector being
          extended.
  
          Element tokens must come first, and pseudo-element tokens must come
          last, and there can only be one of each.  The final selector thus looks
          something like::
  
              [element] [misc self tokens] [misc other tokens] [pseudo-element]
  
          This method does not check for duplicate tokens; those are assumed to
          have been removed earlier, during the search for a hinge.