4 ms·
> Naturally, `read_line` returns the number of bytes read, rather than... the line. That decouples the concern of allocating the buffer from reading the actual
by zozbot234 6y ago
> Naturally, `read_line` returns the number of bytes read, rather than... the line.
That decouples the concern of allocating the buffer from reading the actual line. It should be possible to write a wrapper that does "return the line" (in an owned buffer), and that might be a bit cleaner in simple cases. But the stdlib should focus on providing essential functionality first.
> Oh, and if you test code on a static array of length < 32, and a similar array of length > 32, you will see completely different behaviour.
This will most likely change after const generics get fully stabilized. The current code is already using them under the hood, but the separate behavior for size>32 is being kept for forward compatibility in case const generics need to change.
> you'll note I've not even mentioned how a reader is supposed to comprehend what a <&'a T> is.
That comes up almost exclusively when working with references that have different lifetimes. Rust tries to deduce lifetimes whenever possible so that writing them out isn't necessary most of the time, but sometimes the programmer has to resolve ambiguity. The whole system is still quite intuitive.
- yodelshady 6y ago>It should be possible to write a wrapper that does "return the line" (in an owned buffer), and that might be a bit cleaner in simple cases. So put it in std lib. The point of computers is to not force humans to duplicate identical, basic tasks millions of times, and a major selling point of Rust is zero cost abstractions. Stdlib Rust has everything necessary to write a read_line that returns a good abstraction - Result<&str, Err> - and instead provides a leaky one. I shouldn't be giving a pigs' ear about the buffer length. And come on, a language with vec.windows() in the std library is not minimal. It's just inconsistent.
- Misdicorl 6y agoWell actually you couldn't return an &str, because it would be dropped at the end of the read. You'd need to return either a String (and that would be a big mistake) or a Vec of u8. Which I'm sure you'd also be unhappy with
- yodelshady 6y ago>It should be possible to write a wrapper that does "return the line" Is it, or not? What's the point of lifetimes if you can't manage that trivial outlives-the-creator task in literally every other language ever with them? Why would a String be a big mistake? You STILL think Rust is easy to learn?
- estebank 6y agoIt is. The reason it is not in the stdlib is because it is a foot-gun. Quoting myself from elsewhere in this thread[1]: > Other languages aimed at ease of use will just allocate for you and give you the fully baked contents in a single fn call, but when you're writing code that 1) has to be called often enough where allocations can show up in your flame graphs or 2) the input is big enough that you can't realistically keep the entire thing in memory at once, you suddenly have to care about what the fn is doing internally. Making the default API for file interaction require you pass in your own buffer makes this explicit at the cost of some ease of use. [1]: https://news.ycombinator.com/item?id=23811980 https://news.ycombinator.com/item?id=23811980
- jfkebwjsbx 6y agoIt is not. A very useful function does not mean you have to use it in the hot path or for huge inputs.
- estebank 6y ago>>>>It should be possible to write a wrapper that does "return the line" >>> Is it, or not? >> It is. > It is not. I'm arguing that you can write that function. What Misdicorl is saying is that it would be fn read_line_alloc(&self) -> Result<String> and not fn read_line_alloc(&self) -> Result<&str> because the &str would be an "use-after-free" situation, and Rust won't let you compile it. You need to allocate if you are reading from a file in order to be able to close (or seek) that file. yodelshady seems to be under the impression that this means the functionality they want (single method call that doesn't require passing in a buffer) can't be implemented. It can, it just needs to allocate, the same way that you need to explicitly allocate the buffer you pass into read_line. > A very useful function does not mean you have to use it in the hot path or for huge inputs. I'm also arguing against it being provided in the stdlib because Rust is big in avoiding "you're holding it wrong" kind of answers, by removing the possibility to hold it wrong. Reasonable people can disagree :) I've also found it annoying in the past. If Rust didn't have a design goal of giving programmers full control over the behavior of their code, there are several ergonomics changes that we could make to make it much easier to use, but alas, that is not the language we have and we work with what we can make ergonomic and easy to use.