public class ImmutableObject
{
    public ImmutableObject(int alfa, string bravo)
        => (Alfa, Bravo) = (alfa, bravo);

    public int Alfa { get; }

    public string Bravo { get; }
}

public class ComplexImmutableObject
{
    public ComplexImmutableObject(int charile, ImmutableObject delta)
        => (Charlie, Delta) = (charlie, delta);

    public int Charlie { get; }

    public ImmutableObject Delta { get; }
}

public static class ImmutableObjectExtensins
{
    // I'm tired of writing these 'With...' methods.

    public static ImmutableObject WithAlfa(
        this ImmutableObject source, int alfa)
    {
        return new ImmutableObject(alfa, source.Bravo);
    }

    public static ImmutableObject WithBravo(
        this ImmutableObject source, string bravo)
    {
        return new ImmutableObject(source.Alfa, bravo);
    }

    public static ComplexImmutableObject WithCharlie(
        this ComplexImmutableObject source, int charlie)
    {
        return new ComplexImmutableObject(charlie, source.Delta);
    }

    public static ComplexImmutableObject WithDelta(
        this ComplexImmutableObject source, ImmutableObject delta)
    {
        return new ComplexImmutableObject(source.Charlie, delta);
    }
}

var source = new ComplexImmutableObject(1, new ImmutableObject(2, "foo"));

var revision = source
    .WithCharlie(10)
    .WithDelta(source.Delta.WithBravo("foo"));

using AutoReviser;

var source = new ComplexImmutableObject(1, new ImmutableObject(2, "foo"));

var revision = source.Revise(
    x =>
    x.Charlie == 10 &&
    x.Delta.Bravo == "foo");

using AutoReviser;
using System.Collections.Immutable;

public class HasImmutableArray
{
    public HasImmutableArray(ImmutableArray<string> alfa) => Alfa = alfa;

    public ImmutableArray<string> Alfa { get; }
}

var source = new HasImmutableArray(alfa: ImmutableArray.Create("foo", "bar"));

var revision = source.Revise(
    x =>
    x.Alfa[0] == "baz" &&
    x.Alfa[1] == "foz");

using AutoReviser;
using System.Collections.Immutable;

public class HasImmutableDictionary
{
    public HasImmutableDictionary(ImmutableDictionary<int, string> alfa) => Alfa = alfa;

    public ImmutableDictionary<int, string> Alfa { get; }
}

var source = new HasImmutableArray(alfa: ImmutableDictionary<int, string>.Empty);

var revision = source.Revise(
    x =>
    x.Alfa[0] == "baz" &&
    x.Alfa[1] == "foz");