if (cachedReplacementString is null && cachedMatchEvaluator is null)
            {
                switch (substitute)
                {
                    case string replacement:
                        cachedReplacementString = replacement;
                        break;

                    case ScriptBlock sb:
                        cachedMatchEvaluator = GetMatchEvaluator(context, sb);
                        break;

                    case object val when LanguagePrimitives.TryConvertTo(val, out cachedMatchEvaluator):
                        break;

                    default:
                        cachedReplacementString = PSObject.ToStringParser(context, substitute);
                        break;
                }
            }

            if (cachedReplacementString is not null)
            {
                return regex.Replace(input, cachedReplacementString);
            }
            else
            {
                return regex.Replace(input, cachedMatchEvaluator);
            }

            if (cachedReplacementString is null && cachedMatchEvaluator is null)
            {
                (cachedReplacementString, cachedMatchEvaluator) = substitute switch
                {
                    string replacement => (replacement, (MatchEvaluator) null),
                    ScriptBlock sb => (null, GetMatchEvaluator(context, sb)),
                    { } val when LanguagePrimitives.TryConvertTo(val, out MatchEvaluator me) => (null, me),
                    _ => (PSObject.ToStringParser(context, substitute), null),
                };
            }
            // After first call we will have necessarily either cachedReplacementString or cachedMatchEvaluator.
            return cachedReplacementString is { } replacementString
                ? regex.Replace(input, replacementString)
                : regex.Replace(input, cachedMatchEvaluator);

private abstract class RegexReplacer
{
    protected RegexReplacer(Regex regex)
    {
        ReplacementRegex = regex;
    }

    public abstract string Replace(string input);

    protected Regex ReplacementRegex { get; }
}

private class StringReplacer : RegexReplacer
{
    private readonly string _replacementString;

    public StringReplacer(Regex regex, string replacement)
        : base(regex)
    {
        _replacementString = str;
    }

    public override string Replace(string input)
    {
        return ReplacementRegex.Replace(input, _replacementString);
    }
}

private class MatchEvaluatorReplacer : RegexReplacer
{
    private readonly MatchEvaluator _replacementMatchEvaluator;

    public MatchEvaluatorReplacer(Regex regex, MatchEvaluator replacement)
        : base(regex)
    {
        _replacementMatchEvaluator = replacement;
    }

    public override string Replace(string input)
    {
        return ReplacementRegex.Replace(input, _replacementMatchEvaluator);
    }
}

...

private static RegexReplacer GetSubstituteReplacer(
    ExecutionContext context,
    Regex regex,
    object substitute)
{
    switch (substitute)
    {
        // When the substitution is a string, we can skip all the conversion logic
        case string replacement:
            return new StringReplacer(regex, replacement);

        // ScriptBlocks implement custom regex evaluators, so we must handle them specially
        case ScriptBlock sb:
            return new MatchEvaluatorReplacer(regex, GetMatchEvaluator(context, sb));
    }

    // Try once more to convert the substitute to a match evaluator
    if (LanguagePrimitives.TryConvertTo(subtitute, out MatchEvaluator matchEvaluator))
    {
        return new MatchEvaluatorReplacer(regex, matchEvaluator);
    }

    // Finally, we just treat the substitute as a string
    return new StringReplacer(regex, PSObject.ToStringParser(context, substitute));
}

...

// <main method where we're performing the logic>
{
    RegexReplacer replacer = GetSubstituteReplacer(context, rr, substitute);
    if (list == null)
    {
        ...
        return replacer.Replace(lvalString);
    }
    else
    {
        List<object> resultList = new List<object>();
        while (ParserOps.MoveNext(context, errorPosition, list))
        {
            string lvalString = PSObject.ToStringParser(context, ParserOps.Current(errorPosition, list));
            resultList.Add(replacer.Replace(lvalString));
        }
    }
}