docs: def match_replace_binary(cls, ops, kwargs):
      """Similar to func:`match_replace`, but for arbitrary length operations,
      such that each two pairs of subsequent operands are matched pairwise.
  
          >>> A = wc("A")
          >>> class FilterDupes(Operation):
          ...     _binary_rules = {
          ...          'filter_dupes': (pattern_head(A,A), lambda A: A)}
          ...     simplifications = [match_replace_binary, assoc]
          ...     _neutral_element = 0
          >>> FilterDupes.create(1,2,3,4)         # No duplicates
          FilterDupes(1, 2, 3, 4)
          >>> FilterDupes.create(1,2,2,3,4)       # Some duplicates
          FilterDupes(1, 2, 3, 4)
  
      Note that this only works for *subsequent* duplicate entries:
  
          >>> FilterDupes.create(1,2,3,2,4)       # No *subsequent* duplicates
          FilterDupes(1, 2, 3, 2, 4)
  
      Any operation that uses binary reduction must be associative and define a
      neutral element. The binary rules must be compatible with associativity,
      i.e. there is no specific order in which the rules are applied to pairs of
      operands.
      """
      assert assoc in cls.simplifications, (
          cls.__name__ + " must be associative to use match_replace_binary")
      assert hasattr(cls, '_neutral_element'), (
          cls.__name__ + " must define a neutral element to use "
                         "match_replace_binary")
      fops = _match_replace_binary(cls, list(ops))
      if len(fops) == 1:
          return fops[0]
      elif len(fops) == 0:
          return cls._neutral_element
      else:
          return fops, kwargs