I know immutable objects are preferred to mutable objects for reasoning and maintenance and... but in occasions making a class immutable have some costs, let me explain it with a simple example:

I have a class which draws a text in a box:

class TextDrawer { public string Text {set; get} public RECT Box {set; get; } public void DrawTextInBox() { } } 

It is probable that the Text overflows from the box and part of it wasn't written. Now I have two options:

1- Make the TextDrawer mutable and DrawTextInBox a non-pure function and on each call it draws the remaining part of text in the box.

class TextDrawer { public string Text {set {remaining = text = value;} get {return text; }} public RECT Box {set; get; } private string remaining; public void DrawTextInBox() { ... update remaining part; } } 

2- Keep the TextDrawer immutable and DrawTextInBox a pure function which returns the remaining part, then the caller should keep track of the remaining and pass it again to the TextDrawer or instantiate a new TextDrawer by the remaining text until there is nothing to write.

class TextDrawer { public string Text {set; get} public RECT Box {set; get; } public string DrawTextInBox() { draw as you can; return remaining; } } 

The second approach is immutable but actually shifts the responsibility of updating the remaining part outside of the class. The first approach while it is mutable but just need a call to DrawTextInBox to draw the remaining part.

The logic of the above example was simple but note this logic could be more complex, then I don't know to extract this logic from a class in order to make it immutable or let it be mutable and have the logic inside?