BenchmarkRunner
    .Run<SwitchBenchmark>(
        ManualConfig
        .CreateMinimumViable()
        .AddValidator(DeferredExecutionValidator.DontFailOnError)
        .AddDiagnoser(MemoryDiagnoser.Default)
    );

public class SwitchBenchmark
{
    public IEnumerable<object?[]> Values =>
    [
        [null, null],
        [new Lazy<string>("outer"), null],
        [null, new Lazy<string>("inner")],
        [new Lazy<string>("outer"), new Lazy<string>("inner")]
    ];

    [Benchmark(Baseline = true)]
    [ArgumentsSource(nameof(Values))]
    public Lazy<string>? Dev(Lazy<string>? a, Lazy<string>? b) => Impl.Dev(a, b);

    [Benchmark]
    [ArgumentsSource(nameof(Values))]
    public Lazy<string>? Foo(Lazy<string>? a, Lazy<string>? b) => Impl.Foo(a, b);

    [Benchmark]
    [ArgumentsSource(nameof(Values))]
    public Lazy<string>? Bar(Lazy<string>? a, Lazy<string>? b) => Impl.Bar(a, b);

    [Benchmark]
    [ArgumentsSource(nameof(Values))]
    public Lazy<string>? Baz(Lazy<string>? a, Lazy<string>? b) => Impl.Baz(a, b);
}

static class Impl
{
    public static Lazy<string> Dev(Lazy<string>? outer, Lazy<string>? inner)
    {
        return new Lazy<string>(() => JoinContext(outer, inner));

        static string JoinContext(params Lazy<string>?[] contexts) =>
                string.Join("/", contexts.Where(ctx => ctx is not null).Select(x => x.Value));
    }

    public static Lazy<string>? Foo(Lazy<string>? outer, Lazy<string>? inner) => (outer, inner) switch
    {
        (null, null) => null,
        ({ } a, null) => a,
        (null, { } b) => b,
        ({ } a, { } b) => new(() => a.Value + "/" + b.Value)
    };

    public static Lazy<string>? Bar(Lazy<string>? outer, Lazy<string>? inner)
    {
        return (outer, inner) switch
        {
            (null, null) => null,
            ({ } a, null) => a,
            (null, { } b) => b,
            ({ } a, { } b) => Combine(a, b)
        };

        static Lazy<string> Combine(Lazy<string> outer, Lazy<string> inner) =>
            new(() => outer.Value + "/" + inner.Value);
    }

    public static Lazy<string>? Baz(Lazy<string>? outer, Lazy<string>? inner)
    {
        if (outer is null)
        {
            if (inner is not null)
            {
                return inner;
            }

            return null;
        }

        if (inner is null)
        {
            return outer;
        }

        return new(() => outer.Value + "/" + inner.Value);
    }
}

BenchmarkRunner.Run<Allocations>();

[MemoryDiagnoser]
public class Allocations
{
    [ParamsSource(nameof(ValuesForStep))]
    public object? Step { get; set; }

    public IEnumerable<object?> ValuesForStep => [new(), null];

    [Benchmark(Baseline = true)]
    public object? Func() => TryToProveNodesAreEquivalent(Step);

    [Benchmark]
    public object? LocalFunction() => TryToProveNodesAreEquivalent_New(Step);

    public object? TryToProveNodesAreEquivalent(object? step)
    {
        Func<object, GetTraceMessage> getMessage = static step => _ => $"Equivalency was proven by {step.GetType().Name}";

        if (step is not null)
        {
            return getMessage(step);
        }

        return null;
    }

    public object? TryToProveNodesAreEquivalent_New(object? step)
    {
        if (step is not null)
        {
            return GetMessage(step);

            static GetTraceMessage GetMessage(object step) =>
                _ => $"Equivalency was proven by {step.GetType().Name}";
        }

        return null;
    }

    public delegate string GetTraceMessage(object node);
}