 <p>As others have said, you update properties of an immutable object by creating a new object with updated properties. But let me try to illustrate how this might work with some code.</p> <p>For simplicity, let's say you are modelling a particle system, where each particle moves accordingly to it's velocity.</p> <p>Your model comprises of a set of particles that are updated and then rendered to the screen each frame.</p> <p>In C#, your model implementation might look like this:</p> <pre><code>public class Model { public class Particle { public double X { get; set; } public double Y { get; set; } public double Vx { get; set; } public double Vy { get; set; } } public Model() { this.particles = /* ... initialize a set of particles ... */ } public void Update() { foreach (var p in this.particles) { p.X += p.Vx; p.Y += p.Vy; } } public void Render() { /* ... clear video buffer, init something, etc ... */ foreach (var p in this.particles) { this.RenderParticle(p); } } } </code></pre> <p>Pretty straightforward. As you can see, each frame we go over entire set of particles and update coordinates of each one according to it's velocity.</p> <p>Now, if the particle was immutable, there'd be no way to change it's properties, but as been said, we just create a new one with updated values. But hold on a second, doesn't that mean we'd have to replace the original particle object with an updated one in our set? Yes it does. And doesn't that mean that the <strong>set</strong> now has to be <strong>mutable</strong>? Looks like we just transfered the mutability from one place to another...</p> <p>Well, we could refactor to rebuild the entire set of particles each frame. But then, the property that stores the set would have to be mutable... Hmmm. Do you follow?</p> <p>It appears that at some point you'll have to lose immutability in order to cause effects, and depending on <em>where</em> that point is, your program will or will not have some (arguably) useful properties.</p> <p>In our case (we're making a video game), we technically can postpone the mutability all the way until we get to drawing on the screen. It's good that the screen is mutable, otherwise we'd have to create a new display each frame :)</p> <p>Now, let's see how this could be implemented in F#:</p> <pre><code>type Particle = { X : double Y : double Vx : double Vy : double } type Model = { Particles : Particle seq } module Game = let update model = let updateParticle p = { p with X = p.X + p.Vx; Y = p.Y + p.Vy } { model with Particles = seq { for p in model.Particles do yield updateParticle p } } let render model = for p in model.Particles do Graphics.drawParticle p </code></pre> <p>Note that in order to preserve immutability, we had to make the <code>Update</code> method a function that takes a model object and returns it updated. The <code>Render</code> now also takes the model object as an argument, as we don't keep it in memory anymore because it is immutable.</p> <p>Hope this helps!</p>