def METHOD_NAME(strategy_definition):
    """A decorator that registers the function as a strategy and makes it
    lazily evaluated."""
    _strategies[strategy_definition.__name__] = signature(strategy_definition)
    if never_lazy:
        assert not try_non_lazy
        # We could potentially support never_lazy + force_reusable_values
        # with a suitable wrapper, but currently there are no callers that
        # request this combination.
        assert not force_reusable_values
        return strategy_definition
    from hypothesis.strategies._internal.lazy import LazyStrategy
    @proxies(strategy_definition)
    def accept(*args, **kwargs):
        if try_non_lazy:
            # Why not try this unconditionally?  Because we'd end up with very
            # deep nesting of recursive strategies - better to be lazy unless we
            # *know* that eager evaluation is the right choice.
            try:
                return strategy_definition(*args, **kwargs)
            except Exception:
                # If invoking the strategy definition raises an exception,
                # wrap that up in a LazyStrategy so it happens again later.
                pass
        result = LazyStrategy(strategy_definition, args, kwargs)
        if force_reusable_values:
            # Setting `force_has_reusable_values` here causes the recursive
            # property code to set `.has_reusable_values == True`.
            result.force_has_reusable_values = True
            assert result.has_reusable_values
        return result
    accept.is_hypothesis_strategy_function = True
    return accept