immutability

If you check out the docs for Read , most of the methods accept a &mut self . This makes sense, as reading from something usually updates an internal offset so the next read returns different data. However, this compiles: use std::io::Read; use std::fs::File; fn main() { let file = File::open("/etc/hosts").unwrap(); let vec = &mut Vec::new(); (&file).read_to_end(vec).unwrap(); println!("{:?}", vec); } The file isn't mutable, but the data is certainly being read in. This seems incorrect to me. It was pointed out that there is an impl<'a> Read for &'a File , but the fact that an immutable

In Chapter 3 of the Rust Book , Variables and Mutability , we go through a couple iterations on this theme in order to demonstrate the default, immutable behavior of variables in Rust: fn main() { let x = 5; println!("The value of x is {}", x); x = 6; println!("The value of x is {}", x); } Which outputs: error[E0384]: cannot assign twice to immutable variable `x` --> src/main.rs:4:5 | 2 | let x = 5; | - | | | first assignment to `x` | help: make this binding mutable: `mut x` 3 | println!("The value of x is {}", x); 4 | x = 6; | ^^^^^ cannot assign twice to immutable variable However, because

I have this piece of code that loads Properties from a file: class Config { val properties: Properties = { val p = new Properties() p.load(Thread.currentThread().getContextClassLoader.getResourceAsStream("props")) p } val forumId = properties.get("forum_id") } This seems to be working fine. I have tried moving the initialization of properties into another val, loadedProperties , like this: class Config { val properties: Properties = loadedProps val forumId = properties.get("forum_id") private val loadedProps = { val p = new Properties() p.load(Thread.currentThread().getContextClassLoader

Are Strings mutable in Ruby? According to the documentation doing str = "hello" str = str + " world" creates a new string object with the value "hello world" but when we do str = "hello" str << " world" It does not mention that it creates a new object, so does it mutate the str object, which will now have the value "hello world" ? Dogbert Yes, << mutates the same object, and + creates a new one. Demonstration: irb(main):011:0> str = "hello" => "hello" irb(main):012:0> str.object_id => 22269036 irb(main):013:0> str << " world" => "hello world" irb(main):014:0> str.object_id => 22269036 irb(main

I've frequently heard claims that Haskell doesn't have variables; in particular, this answer claims that it doesn't, and it was upvoted at least nine times and accepted. So does it have variables or not, and why? This question also appears to apply ML, F#, OCaml, Erlang, Oz, Lava, and all SSA intermediate languages. Don Stewart Haskell has immutable variables (variables in the math sense) by default: foo x y = x + y * 2 By default variables are not mutable cells . Haskell also has mutable cells though, but you enable them explicitly: > import Data.IORef (newIORef, readIORef, writeIORef) > v <-

Is this a proper way to declare immutable structs? public struct Pair { public readonly int x; public readonly int y; // Constructor and stuff } I can't think of why this would run into problems, but I just wanted to ask to make sure. In this example, I used ints. What if I used a class instead, but that class is also immutable, like so? That should work fine too, right? public struct Pair { public readonly (immutableClass) x; public readonly (immutableClass) y; // Constructor and stuff } (Aside: I understand that using Properties is more generalizable and allows changing, but this struct is