code: def match_replace_binary(cls, ops, kwargs):
      
      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
docs: 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.