<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def make_variant(cls, converters, re_opts=None, compiled=False, strict=True):
 """ 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). """

        # -- 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