example.ts

interface Person {
   readonly name?: string;
   readonly age?: number;
}

const x = record<Person>({ name: "Bart" }).set({ age: 10 });

const y = x.set({ age: 11 });

record.ts

/*
 * Defines the set method available on any record.
 */
export interface Record<Fields> {
    set(fields: Fields): Record<Fields> & Fields;
}

/*
 * Creates a new record with the specified initial field
 * values, with type that combines the fields with the set
 * method.
 */
export function record<Fields>(init: Fields) {
    return prototype.set(init) as Record<Fields> & Fields;
}

/*
 * Implementation of set method. Nothing fancy.
 */
const prototype = {
    set(fields: any) {
        var clone: any = Object.create(prototype);
        if (this) {
            for (var key of Object.keys(this)) {
                clone[key] = this[key];
            }
        }
        for (var key of Object.keys(fields)) {
            clone[key] = fields[key];
        }
        return clone;
    }
}

The most minimal form of immutable record.

The problem it has is that in TS 2.0 with strict null checks, the fields of Person being optional, they can't be directly used as they might be undefined.

Also the clone operation is very expensive.