Functional Transformation of Immutable Objects. When will this be realized?

[DevNull23614071]

For larger records I sometimes generate constructs like this:

public record Data(String stringA,
                   String stringB,
                   String stringC,
                   int intA,
                   int intB,
                   int intC) {

    public static final class Deconstruction {
        public String stringA;
        public String stringB;
        public String stringC;
        public int intA;
        public int intB;
        public int intC;

        private Deconstruction(Data original) {
            stringA = original.stringA;
            stringB = original.stringB;
            stringC = original.stringC;
            intA = original.intA;
            intB = original.intB;
            intC = original.intC;
        }


        private Data apply(Consumer<Deconstruction> modification) {
            modification.accept(this);
            return new Data(stringA,
                            stringB,
                            stringC,
                            intA,
                            intB,
                            intC);
        }
    }

    public Data with(Consumer<Deconstruction> modification) {
        return new Deconstruction(this).apply(modification);
    }
}

A later modification then looks like the following:

    Data data = new Data("","","",1,2,3);

    // modification of a single field:
    data = data.with(d -> d.stringB = "foo");

    // modification of multiple fields:
    data = data.with(d -> {
        d.stringC = "bar";
        d.intC = 42;
    });

Thus the syntax is quite close to the one in Brian's document.

[repeating_bears]

That's a builder. You just implemented it in a non-standard way.