def find_lazy(*loaders):
    """Decorate a callable as a find rule with lazy loading.

    :param loaders: one or more functions to generate a list of **compiled**
                    regexes to match patterns in a line
    :type loaders: :term:`function`

    Each ``loader`` function must accept a ``settings`` parameter and return a
    list (or tuple) of **compiled** regular expressions::

        import re

        def loader(settings):
            return [re.compile(r'<your_rule_pattern>')]

    It will be called by Sopel when the bot parses the plugin to register the
    find rules to get its regexes. The ``settings`` argument will be the bot's
    :class:`sopel.config.Config` object.

    If any of the ``loader`` functions raises a
    :exc:`~sopel.plugins.exceptions.PluginError` exception, the find rule will
    be ignored; it will not fail the plugin's loading.

    The decorated function will behave like any other :func:`callable`::

        from sopel import plugin

        @plugin.find_lazy(loader)
        def my_find_rule_handler(bot, trigger):
            bot.say('Rule triggered by: %s' % trigger.group(0))

    .. versionadded:: 7.1

    .. seealso::

        When more than one loader is provided, they will be chained together
        with the :func:`sopel.tools.chain_loaders` function.

    """
    def decorator(function):
        function._sopel_callable = True
        if not hasattr(function, 'find_rules_lazy_loaders'):
            function.find_rules_lazy_loaders = []
        function.find_rules_lazy_loaders.extend(loaders)
        return function
    return decorator