docs: def match_replace(cls, ops, kwargs):
      """Match and replace a full operand specification to a function that
      provides a replacement for the whole expression
      or raises a :exc:`.CannotSimplify` exception.
      E.g.
  
      First define an operation::
  
          >>> class Invert(Operation):
          ...     _rules = OrderedDict()
          ...     simplifications = [match_replace, ]
  
      Then some _rules::
  
          >>> A = wc("A")
          >>> A_float = wc("A", head=float)
          >>> Invert_A = pattern(Invert, A)
          >>> Invert._rules.update([
          ...     ('r1', (pattern_head(Invert_A), lambda A: A)),
          ...     ('r2', (pattern_head(A_float), lambda A: 1./A)),
          ... ])
  
      Check rule application::
  
          >>> print(srepr(Invert.create("hallo")))  # matches no rule
          Invert('hallo')
          >>> Invert.create(Invert("hallo"))        # matches first rule
          'hallo'
          >>> Invert.create(.2)                     # matches second rule
          5.0
  
      A pattern can also have the same wildcard appear twice::
  
          >>> class X(Operation):
          ...     _rules = {
          ...         'r1': (pattern_head(A, A), lambda A: A),
          ...     }
          ...     simplifications = [match_replace, ]
          >>> X.create(1,2)
          X(1, 2)
          >>> X.create(1,1)
          1
  
      """
      expr = ProtoExpr(ops, kwargs)
      if LOG:
          logger = logging.getLogger('QNET.create')
      for key, rule in cls._rules.items():
          pat, replacement = rule
          match_dict = match_pattern(pat, expr)
          if match_dict:
              try:
                  replaced = replacement(**match_dict)
                  if LOG:
                      logger.debug(
                          "%sRule %s.%s: (%s, %s) -> %s", ("  " * (LEVEL)),
                          cls.__name__, key, expr.args, expr.kwargs, replaced)
                  return replaced
              except CannotSimplify:
                  if LOG_NO_MATCH:
                      logger.debug(
                          "%sRule %s.%s: no match: CannotSimplify",
                          ("  " * (LEVEL)), cls.__name__, key)
                  continue
          else:
              if LOG_NO_MATCH:
                  logger.debug(
                      "%sRule %s.%s: no match: %s", ("  " * (LEVEL)),
                      cls.__name__, key, match_dict.reason)
      # No matching rules
      return ops, kwargs