rust - What is the difference between type casting by setting the type of a variable and using `as`?

Question

What is the difference between these two cases? Why does the commented line compile but the last line in the main is incorrect?

How to cut string (substr in C++ with non-const arguments) without an extra variable?

use std::fs::File;
use std::io;
use std::io::Read;

fn read_string(filename: &str) -> Result<String, io::Error> {
    let mut s = String::new();
    File::open(filename)?.read_to_string(&mut s)?;
    Ok(s)
}

fn main() {
    let s = read_string("tt.txt").expect("Wow");

    // let s2: String = s.chars().skip(0).take(s.len() -2).collect();

    println!(
        "{}",
        s.chars().skip(0).take(s.len() - 2).collect() as String
    );
}

Answer 1

Explicitly typing a variable is not a type cast.

As thoroughly explained elsewhere, Iterator::collect requires knowing the concrete type to collect into.

A type cast, such as that performed by as, requires converting from one type to another. You've specified the second type (String), but there's still no way for the compiler to deduce what the first type should be.

Turbofish

The syntax you want in today's Rust is the turbofish:

use std::fs;

fn main() {
    let s = fs::read_to_string("tt.txt").expect("Wow");

    println!(
        "{}",
        s.chars().skip(0).take(s.len() - 2).collect::<String>()
    );
}

• How to put a type annotation in an iterator's collect statement?
• What is the syntax: `instance.method::<SomeThing>()`?

Type Ascription

As a nightly feature, you could also use the experimental type ascription:

#![feature(type_ascription)]

use std::fs;

fn main() {
    let s = fs::read_to_string("tt.txt").expect("Wow");

    println!(
        "{}",
        s.chars().skip(0).take(s.len() - 2).collect(): String
    );
}

• What is type ascription?

Other

You don't need to write read_string.

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