Rust – Tek Shinobi

Turbofish in rust

March 21, 2021
Rust, Uncategorized

Consider the following code (or run it in rust playground here):

fn main() {
    let a:Vec<u32> = vec![1, 2, 3];

    let doubled = a.iter().map(|&x| x * 2).collect();

    assert_eq!(vec![2, 4, 6], doubled);
}

fn main() {

let a:Vec<u32> = vec![1, 2, 3];

let doubled = a.iter().map(|&x| x * 2).collect();

assert_eq!(vec![2, 4, 6], doubled);

}

If you ran it in the playground linked above, you will see the following compiler error.

error[E0282]: type annotations needed
 --> src/main.rs:4:9
  |
4 |     let doubled = a.iter().map(|&x| x * 2).collect();
  |         ^^^^^^^ consider giving `doubled` a type

error: aborting due to previous error

For more information about this error, try `rustc --explain E0282`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

error[E0282]: type annotations needed

--> src/main.rs:4:9

4 | let doubled = a.iter().map(|&x| x * 2).collect();

| ^^^^^^^ consider giving `doubled` a type

error: aborting due to previous error

For more information about this error, try `rustc --explain E0282`.

error: could not compile `playground`

To learn more, run the command again with --verbose.

Because collect() is so general, it can cause problems with type inference. As such, collect() is one of the few times you’ll see the syntax affectionately […]

Rust File Builder pattern for file read writes

March 20, 2021
Rust

Consider the following test code that creates a file, writes to it and then reads back to confirm what it wrote.

#[cfg(test)]
mod tests {
    #[allow(unused_imports)]
    use super::*;
    use std::fs::{self, File, OpenOptions};
    use std::io::{Read, Seek, SeekFrom, Write};
    use tempfile::{tempdir, tempfile, NamedTempFile};

    #[test]
    fn test_file() {
        let dir = tempdir().unwrap();
        let file_path = dir.path().join("foo.txt");
        let mut file = File::create(file_path.to_owned()).unwrap();
        file.write_all("Bar Baz".as_bytes())
           .unwrap();
        file.seek(SeekFrom::Start(0)).unwrap();
        let mut contents = String::new();
        file.read_to_string(&mut contents).unwrap();
        assert_eq!(contents, "Bar Baz");
        drop(file);
        dir.close().unwrap();
     }
}

#[cfg(test)]

mod tests {

#[allow(unused_imports)]

use super::*;

use std::fs::{self, File, OpenOptions};

use std::io::{Read, Seek, SeekFrom, Write};

use tempfile::{tempdir, tempfile, NamedTempFile};

#[test]

fn test_file() {

let dir = tempdir().unwrap();

let file_path = dir.path().join("foo.txt");

let mut file = File::create(file_path.to_owned()).unwrap();

file.write_all("Bar Baz".as_bytes())

.unwrap();

file.seek(SeekFrom::Start(0)).unwrap();

let mut contents = String::new();

file.read_to_string(&mut contents).unwrap();

assert_eq!(contents, "Bar Baz");

drop(file);

dir.close().unwrap();

}

This test fails with a very cryptic and unhelpful message:

thread 'tests::test_tempfiles' panicked at 'called `Result::unwrap()` 
on an `Err` value: Os { code: 9, kind: Other, message: "Bad file descriptor" }'

1 2	thread 'tests::test_tempfiles' panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 9, kind: Other, message: "Bad file descriptor" }'

It will panic at this line file.read_to_string(&mut contents).unwrap(); What is happening is that File::create and File::open in rust are actually syntactic sugar […]

Temporary files and Temporary directory in Rust

March 20, 2021
Rust

I was looking for Python style temporary files and temporary directories in Rust. Very handy when writing tests for simulating actual files, or when we need to use files once or cache large amount of data for short time. We then let the operating system delete the files at a later time automatically or by […]

self in use statement in rust

March 18, 2021
Rust

I was going through some library code in a rust crate and this pattern had my head scratching: std::io::{self,Cursor}; What this is equivalent to is: use std::io; use std::io::Cursor; which means explicitly use std::io::Cursor and also use std::io itself. Thus, Cursor need not be prefixed but you’d still need to do io::BufReader and so on.

Rust tips: Box, RC, Arc, Cell, RefCell, Mutex

February 28, 2021
Rust

Difference Between Box, Rc, Arc, Cell (and its various variants.. RefCell, Mutex, RwLock) in Rust: Box is for single ownership. A great use case is to use this when we want to store primitive types (stored on stack) on heap. Rc is for multiple ownership. Arc is for multiple ownership, but threadsafe. RefCell is for […]

Tek Shinobi

Rust (5)

Turbofish in rust

Rust File Builder pattern for file read writes

Temporary files and Temporary directory in Rust

self in use statement in rust

Rust tips: Box, RC, Arc, Cell, RefCell, Mutex

Recent Posts

Recent Comments

Archives

Categories

Meta