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

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?

Answer 2

The issue lies in the .collect() method. From it's documentation:

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 known as the 'turbofish': ::<>. This helps the inference algorithm understand specifically which collection you're trying to collect into.

The compiler cannot infer the collection type you want to use, hence the need to specify it explicitly.

Some examples:

fn main() {
    let s = String::from("magic");

    //different ways to specify the target type
    //1. -> explicitly declaring the variable type
    //2. -> turbofish syntax (great article about it: https://matematikaadit.github.io/posts/rust-turbofish.html)

    let a1: String = s.chars().skip(0).take(s.len() - 2).collect();
    let a2 = s.chars().skip(0).take(s.len() - 2).collect::<String>();

    let b1: Vec<char> = s.chars().skip(0).take(s.len() - 2).collect();
    let b2 = s.chars().skip(0).take(s.len() - 2).collect::<Vec<char>>();

    let c1: HashSet<char> = s.chars().skip(0).take(s.len() - 2).collect();
    let c2 = s.chars().skip(0).take(s.len() - 2).collect::<HashSet<char>>();
}

As the examples show, many target types are valid and there is no way for the compiler to decide what your intention was.