How to do simple math with a list of numbers from a file and print out the result in Rust?

Question

use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use std::iter::Iterator;

fn main() -> std::io::Result<()> {
    let file = File::open("input")?; // file is input
    let mut buf_reader = BufReader::new(file);

    let mut contents = String::new();
    buf_reader.read_to_string(&mut contents)?;

    for i in contents.parse::<i32>() {
        let i = i / 2;
        println!("{}", i);
    }

    Ok(())
}

list of numbers:

Your code is fine. If this is about getting some advice for writing an idiomatic code, you can post on codereview.stackexchange.com — Boiethios, Dec 09 '19 at 06:48
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=3e64b3e7e85fcb3ae357e05b1c3ab890 @FrenchBoiethios the code is not "fine" by the way — Stargateur, Dec 09 '19 at 06:49
@Stargateur The OP didn't say anything about any requirement, so that's hard to answer anyway — Boiethios, Dec 09 '19 at 06:55
@FrenchBoiethios, the file is local so it wouldn't show up on an online ide. — William Vandrake, Dec 09 '19 at 07:00
im not getting any error just Finished dev [unoptimized + debuginfo] target(s) in 0.00s Running `/home/whilhelm/PycharmProjects/untitled4/target/debug/untitled4 main input` — William Vandrake, Dec 09 '19 at 07:01
you don't get anything because Result implement intoiterator and so your for loop do not cycle over your numbers but over one result from all your string and obviously "50951\n69212..." is not a valid number. — Stargateur, Dec 09 '19 at 07:10

score 3 · Answer 1 · edited Dec 09 '19 at 12:51

str::parse::<i32> can only parse a single number at a time, so you will need to split the text first and then parse each number one by one. For example if you have one number per line and no extra whitespace, you can use BufRead::lines to process the text line by line:

use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() -> std::io::Result<()> {
    let file = File::open("input")?; // file is input
    let mut buf_reader = BufReader::new(file);

    for line in buf_reader.lines() {
        let value = line?
            .parse::<i32>()
            .expect("Not able to parse: Content is malformed !");

        println!("{}", value / 2);
    }

    Ok(())
}

As an extra bonus this avoids reading the whole file into memory, which can be important if the file is big.

score 0 · Answer 2 · answered Dec 11 '19 at 15:15

For tiny examples like this, I'd read the entire string at once, then split it up on lines.

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let contents = fs::read_to_string("input")?;
    for line in contents.trim().lines() {
        let i: i32 = line.trim().parse()?;
        let i = i / 2;
        println!("{}", i);
    }

    Ok(())
}

See also:

What's the de-facto way of reading and writing files in Rust 1.x?

For tightly-controlled examples like this, I'd ignore errors occurring while parsing:

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let contents = fs::read_to_string("input")?;
    for i in contents.trim().lines().flat_map(|l| l.trim().parse::<i32>()) {
        let i = i / 2;
        println!("{}", i);
    }

    Ok(())
}

See also:

Why does `Option` support `IntoIterator`?

For fixed-input examples like this, I'd avoid opening the file at runtime at all, pushing the error to compile-time:

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let contents = include_str!("../input");
    for i in contents.trim().lines().flat_map(|l| l.trim().parse::<i32>()) {
        let i = i / 2;
        println!("{}", i);
    }

    Ok(())
}

See also:

Is there a good way to include external resource data into Rust source code?

If I wanted to handle failures to parse but treat the iterator as if errors were impossible, I'd use Itertools::process_results:

use itertools; // 0.8.2

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let contents = include_str!("../input");

    let numbers = contents.trim().lines().map(|l| l.trim().parse::<i32>());
    let sum = itertools::process_results(numbers, |i| i.sum::<i32>());

    println!("{:?}", sum);

    Ok(())
}

See also:

How to do simple math with a list of numbers from a file and print out the result in Rust?

2 Answers2

Linked

Related