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

 class Mutable 
 {
 private int i;
 public Mutable(int _i) { i = _i}
 public void Print() // impure function
 {
 print(i);
 i++; // logic inside
 }
 }

 ... caller
 int i =1;
 Immutable m = new Mutable(i);
 while (true)
 { 
 m.Print();
 }

I call it mutable because its internal state changes and `Print` varies on each call.

Versus.

 class Immutable 
 {
 private int i;
 public Mutable(int _i) { i = _i}
 public int Print() // pure function
 {
 print(i);
 return i; 
 }
 }

 ... caller
 int i =1;
 while (true)
 {
 Immutable im = new Immutable(i);
 i = im.Print();
 i++; // logic outside
 }


----------
My actual problem (**you may skip this example below**)

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

 class TextDrawer
 {
 private string text;
 private Rectangle box;
 public TextDrawer(_text, _box) {...}
 public void DrawTextInBox()
 {
 }
 }

It is probable that the `Text` overflows from the box and part of it wasn't written. I should know the remaining unwritten part to draw it in a new box.(in fact I take an snapshot of the old box as a video frame and need to make a new frame for the remaining text to make a video of the text)

Now I have two options:

1- Make the `TextDrawer` mutable (its internal state is mutable) and `DrawTextInBox` a non-pure function and on each call it draws the remaining part of text in the box.


 class TextDrawer
 {
 
 private string text;
 private Rectangle box;
 private string remaining; 
 
 public TextDrawer(_text, _box)
 {
 remaining = text = _text;
 box = _box;
 } 
 public void DrawTextInBox()
 {
 draw as you can from remaining
 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
 {
 private string text;
 private Rectangle box;
 public TextDrawer(_text, _box) { ... }
 public string DrawTextInBox()
 {
 draw as you can from text;
 return remaining part;
 }
 }

The second approach is immutable but actually shifts the responsibility of updating the remaining part outside of the class. The first approach is mutable (am i correct? because its internal state (the remaining part is mutable) but it encapsulates the logic and just need a call to `DrawTextInBox` to draw the remaining part. 


----------


The logic of the above examples was simple but 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?