docs: def merge(constraints):
      """Merge ``constraints``.
  
      It removes dupplicate, pruned and merged constraints.
  
      :param constraints: Current constraints.
      :type constraints: Iterable of :class:`.Constraint` objects.
      :rtype: :func:`list` of :class:`.Constraint` objects.
      :raises: :exc:`.ExclusiveConstraints`
  
      """
      # Dictionary :class:`Operator`: set of :class:`Version`.
      operators = defaultdict(set)
      for constraint in constraints:
          operators[constraint.operator].add(constraint.version)
      # Get most recent version required by > constraints.
      if gt in operators:
          gt_ver = sorted(operators[gt])[-1]
      else:
          gt_ver = None
      # Get most recent version required by >= constraints.
      if ge in operators:
          ge_ver = sorted(operators[ge])[-1]
      else:
          ge_ver = None
      # Get least recent version required by < constraints.
      if lt in operators:
          lt_ver = sorted(operators[lt])[0]
      else:
          lt_ver = None
      # Get least recent version required by <= constraints.
      if le in operators:
          le_ver = sorted(operators[le])[0]
      else:
          le_ver = None
      # Most restrictive LT/LE constraint.
      l_constraint = None
      if le_ver:
          if lt_ver:
              le_constraint = Constraint(le, le_ver)
              lt_constraint = Constraint(lt, lt_ver)
  
              if le_ver < lt_ver:
                  # <= 1, < 2
                  l_constraint = le_constraint
                  l_less_restrictive_c = lt_constraint
              else:
                  # <= 2, < 1
                  # <= 2, < 2
                  l_constraint = lt_constraint
                  l_less_restrictive_c = le_constraint
  
              LOGGER.debug('Removed constraint %s because it is less '
                           'restrictive than %s', l_less_restrictive_c,
                           l_constraint)
          else:
              l_constraint = Constraint(le, le_ver)
      elif lt_ver:
          l_constraint = Constraint(lt, lt_ver)
      # Most restrictive GT/GE constraint.
      g_constraint = None
      if ge_ver:
          if gt_ver:
              gt_constraint = Constraint(gt, gt_ver)
              ge_constraint = Constraint(ge, ge_ver)
  
              if ge_ver <= gt_ver:
                  # >= 1, > 2
                  # >= 2, > 2
                  g_constraint = gt_constraint
                  g_less_restrictive_c = ge_constraint
              else:
                  # >= 2, > 1
                  g_constraint = ge_constraint
                  g_less_restrictive_c = gt_constraint
  
              LOGGER.debug('Removed constraint %s because it is less '
                           'restrictive than %s', g_less_restrictive_c,
                           g_constraint)
          else:
              g_constraint = Constraint(ge, ge_ver)
      elif gt_ver:
          g_constraint = Constraint(gt, gt_ver)
  
      # Check if g_constraint and l_constraint are conflicting
      if g_constraint and l_constraint:
          if g_constraint.version == l_constraint.version:
              if g_constraint.operator == ge and l_constraint.operator == le:
                  # Merge >= and <= constraints on same version to a ==
                  # constraint
                  operators[eq].add(g_constraint.version)
                  LOGGER.debug('Merged constraints: %s and %s into ==%s',
                               l_constraint, g_constraint, g_constraint.version)
                  l_constraint, g_constraint = None, None
              else:
                  raise ExclusiveConstraints(g_constraint, [l_constraint])
          elif g_constraint.version > l_constraint.version:
              raise ExclusiveConstraints(g_constraint, [l_constraint])
  
      ne_constraints = [Constraint(ne, v) for v in operators[ne]]
      eq_constraints = [Constraint(eq, v) for v in operators[eq]]
  
      if eq_constraints:
          eq_constraint = eq_constraints.pop()
          # An eq constraint conflicts with other constraints
          if g_constraint or l_constraint or ne_constraints or eq_constraints:
              conflict_list = [c for c in (g_constraint, l_constraint) if c]
              conflict_list.extend(ne_constraints)
              conflict_list.extend(eq_constraints)
              raise ExclusiveConstraints(eq_constraint, conflict_list)
  
          return [eq_constraint]
  
      else:
          constraints = ne_constraints + [g_constraint, l_constraint]
          return [c for c in constraints if c]