Use cases?

I originally was using it as a monkey patch for my console singleton. I needed to add an equivalent to "\b \b" for an IO:Memory backed buffer. I am sure there are more.

This is fine, but there's already a File#truncate, and that method takes a size and a default which is zero. It'd be good to keep these two method's signatures they same considering they're both IOs.

Probably best to add an explicit size option to IO::Memory's truncate, and then make a breaking change to set the default for File's truncate to pos.

It makes no sense to have a negative size. I will be making a negative value similar to a negative value in a range. In other words

io = IO::Memory.new()
io << "hello world"
io.truncate(-6)
io.pos = 0
io.gets().should eq("hello")

What do you think about having it take an optional IO::Memory::Seek so it can still be relative to the position if specified?

I really want File#truncate and IO::Memory#truncate to behave as similar as possible. This means being able to extend it past the current size by padding with zeroes. Also supporting negative sizes in File#truncate.

I can understand the negative values, I have already implemented them for IO::Memory and will for File but I am not a fan of using truncate to extend the size. Perhaps a method like extend or resize?

Note that setting pos of an IO::Memory past its size, and then writing to it, will fill the gap with \0. This is similar to what happens with a File, and with Ruby's StringIO. So these behave the same in Crystal:

# Using a file
io = File.open("test.txt", "w+")
io.pos = 3
io.puts 1

io.rewind

p io.gets_to_end # => "\u0000\u0000\u00001\n"

io.close

# Using an IO::Memory
io = IO::Memory.new
io.pos = 3
io.puts 1

io.rewind

p io.gets_to_end # => "\u0000\u0000\u00001\n"

io.close

Truncating a file past its size (or well, past its maximum current size) fills that with \0:

io = File.open("test.txt", "w+")
io.truncate(5)
io.puts 1

io.rewind

p io.gets_to_end # => "1\n\u0000\u0000\u0000"

io.close

and the same should happen with IO::Memory.

By the way, Ruby's StringIO implements truncate and also behaves like that.

ftruncate is the syscall to extend the size of a file from a filedescriptor, maybe we should name it resize, or just #size=, who knows. I actually like the #size= API because then you can do size += and size -= to naturally express differences.

While working on this I noticed the growth factor is 2, which is arguably the worst choice. Based on this article and what NSMutableArray uses internally I propose 1.625.

@asterite, @ysbaddaden - Thoughts?

No opinion, that depends on the memory allocator and growth. With my GC you'll never reuse the previous allocation anyway.

Please revert the growth factor change. You just made your PR unmergable because we now must discuss two things instead of one. Please open a new issue or PR to discuss the growth factor change, which should also be applied to arrays, maybe.

I will revert the growth factor and do some benchmarking. If that all works out I’ll open a new PR.

Ready for review.

@straight-shoota - Thanks for the review. I am absolutely slammed with work ATM. I won't be able to take a stab at this for a little while.