Wie drucke ich in Rust den Typ einer Variablen?

Question

Ich habe Folgendes:

let mut my_number = 32.90;

Wie drucke ich den Typ von my_number aus?

Die Verwendung von type und type_of hat nicht funktioniert. Gibt es einen anderen Weg, um den Typ der Zahl auszudrucken?

Answer 1

UPD Das Folgende funktioniert nicht mehr. Überprüfen Sie Shubhams Antwort für die Korrektur.

Überprüfen Sie std::intrinsics::get_tydesc(). Es befindet sich derzeit im "experimentellen" Zustand, aber es ist in Ordnung, wenn Sie nur mit dem Typsystem herumspielen.

Überprüfen Sie das folgende Beispiel:

fn print_type_of(_: &T) -> () {
    let type_name =
        unsafe {
            (*std::intrinsics::get_tydesc::()).name
        };
    println!("{}", type_name);
}

fn main() -> () {
    let mut my_number = 32.90;
    print_type_of(&my_number);       // gibt "f64" aus
    print_type_of(&(vec!(1, 2, 4))); // gibt "collections::vec::Vec" aus
}

Dies ist das, was intern verwendet wird um den berühmten {:?} Formatter zu implementieren.

Answer 2

** UPDATE ** Dies wurde nicht überprüft, ob es in letzter Zeit funktioniert hat.

Ich habe eine kleine Kiste zusammengestellt, um dies basierend auf vbo's Antwort zu tun. Es gibt Ihnen ein Makro, um den Typ zurückzugeben oder auszudrucken.

Fügen Sie dies Ihrer Cargo.toml-Datei hinzu:

[dependencies]
t_bang = "0.1.2"

Dann können Sie es wie folgt verwenden:

#[macro_use] extern crate t_bang;
use t_bang::*;

fn main() {
  let x = 5;
  let x_type = t!(x);
  println!("{:?}", x_type);  // gibt aus: "i32"
  pt!(x);                    // gibt aus: "i32"
  pt!(5);                    // gibt aus: "i32"
}

Answer 3

#![feature(type_name_of_val)]
use std::any::type_name_of_val;
fn main() {
    let mut my_number = 32.90;
    println!("{}", type_name_of_val(&my_number));
}

Answer 4

Neu hinzugefügt in Version 1.38 std::any::type_name

Verwenden Sie std::any::type_name;

fn typ_von(_: T) -> &'static str {
    type_name::()
}
fn main() {
    let x = 21;
    let y = 2.5;
    println!("{}", typ_von(&y));
    println!("{}", typ_von(x));
}

Answer 5

Sie können auch den einfachen Ansatz verwenden, die Variable in println!("{:?}", var) zu verwenden. Wenn Debug nicht für den Typ implementiert ist, können Sie den Typ in der Fehlermeldung des Compilers sehen:

mod some {
    pub struct SomeType;
}

fn main() {
    let unknown_var = some::SomeType;
    println!("{:?}", unknown_var);
}

(playpen)

Es ist schmutzig, aber es funktioniert.