code: def make_variant(cls, converters, re_opts=None, compiled=False, strict=True):
          
          # -- NOTE: Uses double-dispatch with regex pattern rematch because
          #          match is not passed through to primary type converter.
          assert converters, "REQUIRE: Non-empty list."
          if len(converters) == 1:
              return converters[0]
          if re_opts is None:
              re_opts = cls.default_re_opts
  
          pattern = r")|(".join([tc.pattern for tc in converters])
          pattern = r"("+ pattern + ")"
          group_count = len(converters)
          for converter in converters:
              group_count += pattern_group_count(converter.pattern)
  
          if compiled:
              convert_variant = cls.__create_convert_variant_compiled(converters,
                                                                  re_opts, strict)
          else:
              convert_variant = cls.__create_convert_variant(re_opts, strict)
          convert_variant.pattern = pattern
          convert_variant.converters = tuple(converters)
          # OLD: convert_variant.group_count = group_count
          convert_variant.regex_group_count = group_count
          return convert_variant
docs: Creates a type converter for a number of type converter alternatives.
          The first matching type converter is used.
  
          REQUIRES: type_converter.pattern attribute
  
          :param converters: List of type converters as alternatives.
          :param re_opts:  Regular expression options zu use (=default_re_opts).
          :param compiled: Use compiled regexp matcher, if true (=False).
          :param strict:   Enable assertion checks.
          :return: Type converter function object.
  
          .. note::
  
              Works only with named fields in :class:`parse.Parser`.
              Parser needs group_index delta for unnamed/fixed fields.
              This is not supported for user-defined types.
              Otherwise, you need to use :class:`parse_type.parse.Parser`
              (patched version of the :mod:`parse` module).