Eu tenho o seguinte:
let mut my_number = 32.90;
Como imprimo o tipo de my_number
?
Usando type
e type_of
não funcionou. Existe outra maneira de imprimir o tipo do número?
Eu tenho o seguinte:
let mut my_number = 32.90;
Como imprimo o tipo de my_number
?
Usando type
e type_of
não funcionou. Existe outra maneira de imprimir o tipo do número?
Respostas:
Se você apenas deseja descobrir o tipo de uma variável e está disposto a fazê-lo em tempo de compilação, pode causar um erro e solicitar que o compilador a escolha.
Por exemplo, defina a variável para um tipo que não funcione :
let mut my_number: () = 32.90;
// let () = x; would work too
error[E0308]: mismatched types
--> src/main.rs:2:29
|
2 | let mut my_number: () = 32.90;
| ^^^^^ expected (), found floating-point number
|
= note: expected type `()`
found type `{float}`
let mut my_number = 32.90;
my_number.what_is_this();
error[E0599]: no method named `what_is_this` found for type `{float}` in the current scope
--> src/main.rs:3:15
|
3 | my_number.what_is_this();
| ^^^^^^^^^^^^
let mut my_number = 32.90;
my_number.what_is_this
error[E0610]: `{float}` is a primitive type and therefore doesn't have fields
--> src/main.rs:3:15
|
3 | my_number.what_is_this
| ^^^^^^^^^^^^
Eles revelam o tipo, que neste caso não é totalmente resolvido. É chamado de "variável de ponto flutuante" no primeiro exemplo e " {float}
" nos três exemplos; esse é um tipo parcialmente resolvido que pode terminar f32
ou f64
, dependendo de como você o usa. " {float}
" Não é um nome de tipo legal, é um espaço reservado que significa "Não tenho muita certeza do que é isso", mas é um número de ponto flutuante. No caso de variáveis de ponto flutuante, se você não o restringir, o padrão será f64
¹. (Um literal inteiro não qualificado será padronizado como i32
.)
Veja também:
Still Ainda pode haver maneiras de confundir o compilador para que ele não possa decidir entre f32
e f64
; Não tenho certeza. Costumava ser tão simples quanto 32.90.eq(&32.90)
, mas isso trata tanto como f64
agora e é feliz, então eu não sei.
ImageBuffer<_, Vec<_>>
que não me ajude muito quando estou tentando escrever uma função que usa uma dessas coisas como parâmetro. E isso acontece no código que de outra forma compila até eu adicionar o :()
. Não existe melhor maneira?
Há uma função instável std::intrinsics::type_name
que pode lhe dar o nome de um tipo, embora você precise usar uma compilação noturna do Rust (é improvável que isso funcione no Rust estável). Aqui está um exemplo:
#![feature(core_intrinsics)]
fn print_type_of<T>(_: &T) {
println!("{}", unsafe { std::intrinsics::type_name::<T>() });
}
fn main() {
print_type_of(&32.90); // prints "f64"
print_type_of(&vec![1, 2, 4]); // prints "std::vec::Vec<i32>"
print_type_of(&"foo"); // prints "&str"
}
#![feature(core_intrinsics)]
print_type_of
está usando referências ( &T
), não valores ( T
), então você deve passar &&str
ao invés de &str
; isto é, print_type_of(&"foo")
e não print_type_of("foo")
.
std::any::type_name
é estável desde a ferrugem 1.38: stackoverflow.com/a/58119924
Você pode usar a std::any::type_name
função Isso não precisa de um compilador noturno ou de uma caixa externa, e os resultados são bastante corretos:
fn print_type_of<T>(_: &T) {
println!("{}", std::any::type_name::<T>())
}
fn main() {
let s = "Hello";
let i = 42;
print_type_of(&s); // &str
print_type_of(&i); // i32
print_type_of(&main); // playground::main
print_type_of(&print_type_of::<i32>); // playground::print_type_of<i32>
print_type_of(&{ || "Hi!" }); // playground::main::{{closure}}
}
Esteja avisado: como dito na documentação, essas informações devem ser usadas apenas para fins de depuração:
Isto é destinado ao uso em diagnóstico. O conteúdo e o formato exatos da sequência não são especificados, exceto uma descrição do tipo de melhor esforço.
Se você deseja que sua representação de tipo permaneça a mesma entre as versões do compilador, use uma característica, como na resposta do phicr .
Se você conhece todos os tipos de antemão, pode usar características para adicionar um type_of
método:
trait TypeInfo {
fn type_of(&self) -> &'static str;
}
impl TypeInfo for i32 {
fn type_of(&self) -> &'static str {
"i32"
}
}
impl TypeInfo for i64 {
fn type_of(&self) -> &'static str {
"i64"
}
}
//...
Nada de intrísico ou nada, portanto, embora mais limitada, essa é a única solução que fornece uma string e é estável. (veja a resposta de French Boiethios ) No entanto, é muito trabalhoso e não leva em consideração os parâmetros de tipo, para que pudéssemos ...
trait TypeInfo {
fn type_name() -> String;
fn type_of(&self) -> String;
}
macro_rules! impl_type_info {
($($name:ident$(<$($T:ident),+>)*),*) => {
$(impl_type_info_single!($name$(<$($T),*>)*);)*
};
}
macro_rules! mut_if {
($name:ident = $value:expr, $($any:expr)+) => (let mut $name = $value;);
($name:ident = $value:expr,) => (let $name = $value;);
}
macro_rules! impl_type_info_single {
($name:ident$(<$($T:ident),+>)*) => {
impl$(<$($T: TypeInfo),*>)* TypeInfo for $name$(<$($T),*>)* {
fn type_name() -> String {
mut_if!(res = String::from(stringify!($name)), $($($T)*)*);
$(
res.push('<');
$(
res.push_str(&$T::type_name());
res.push(',');
)*
res.pop();
res.push('>');
)*
res
}
fn type_of(&self) -> String {
$name$(::<$($T),*>)*::type_name()
}
}
}
}
impl<'a, T: TypeInfo + ?Sized> TypeInfo for &'a T {
fn type_name() -> String {
let mut res = String::from("&");
res.push_str(&T::type_name());
res
}
fn type_of(&self) -> String {
<&T>::type_name()
}
}
impl<'a, T: TypeInfo + ?Sized> TypeInfo for &'a mut T {
fn type_name() -> String {
let mut res = String::from("&mut ");
res.push_str(&T::type_name());
res
}
fn type_of(&self) -> String {
<&mut T>::type_name()
}
}
macro_rules! type_of {
($x:expr) => { (&$x).type_of() };
}
Vamos usá-lo:
impl_type_info!(i32, i64, f32, f64, str, String, Vec<T>, Result<T,S>)
fn main() {
println!("{}", type_of!(1));
println!("{}", type_of!(&1));
println!("{}", type_of!(&&1));
println!("{}", type_of!(&mut 1));
println!("{}", type_of!(&&mut 1));
println!("{}", type_of!(&mut &1));
println!("{}", type_of!(1.0));
println!("{}", type_of!("abc"));
println!("{}", type_of!(&"abc"));
println!("{}", type_of!(String::from("abc")));
println!("{}", type_of!(vec![1,2,3]));
println!("{}", <Result<String,i64>>::type_name());
println!("{}", <&i32>::type_name());
println!("{}", <&str>::type_name());
}
resultado:
i32
&i32
&&i32
&mut i32
&&mut i32
&mut &i32
f64
&str
&&str
String
Vec<i32>
Result<String,i64>
&i32
&str
UPD O seguinte não funciona mais. Verifique a resposta de Shubham para correção.
Confira std::intrinsics::get_tydesc<T>()
. Ele está no estado "experimental" no momento, mas não há problema se você estiver apenas invadindo o sistema de tipos.
Confira o seguinte exemplo:
fn print_type_of<T>(_: &T) -> () {
let type_name =
unsafe {
(*std::intrinsics::get_tydesc::<T>()).name
};
println!("{}", type_name);
}
fn main() -> () {
let mut my_number = 32.90;
print_type_of(&my_number); // prints "f64"
print_type_of(&(vec!(1, 2, 4))); // prints "collections::vec::Vec<int>"
}
É isso que é usado internamente para implementar o famoso {:?}
formatador.
** ATUALIZAÇÃO ** Isso não foi verificado para funcionar recentemente.
Eu montei uma pequena caixa para fazer isso com base na resposta do vbo. Ele fornece uma macro para retornar ou imprimir o tipo.
Coloque isso no seu arquivo Cargo.toml:
[dependencies]
t_bang = "0.1.2"
Então você pode usá-lo assim:
#[macro_use] extern crate t_bang;
use t_bang::*;
fn main() {
let x = 5;
let x_type = t!(x);
println!("{:?}", x_type); // prints out: "i32"
pt!(x); // prints out: "i32"
pt!(5); // prints out: "i32"
}
#![feature]
não pode ser usado no canal de lançamento estável`
Você também pode usar a abordagem simples de utilizar a variável em println!("{:?}", var)
. Se Debug
não estiver implementado para o tipo, você poderá ver o tipo na mensagem de erro do compilador:
mod some {
pub struct SomeType;
}
fn main() {
let unknown_var = some::SomeType;
println!("{:?}", unknown_var);
}
( cercadinho )
Está sujo, mas funciona.
Debug
não for implementado - esse é um caso bastante improvável. Uma das primeiras coisas que você deve fazer para qualquer estrutura é adicionar #[derive(Debug)]
. Eu acho que os tempos em que você não quer Debug
são muito pequenos.
println!("{:?}", unknown_var);
? É uma interpolação de cordas, mas por que o :?
interior dos colchetes? @DenisKolodin
Debug
porque não está implementado, mas você pode usá-lo {}
também.
Existe uma resposta @ChrisMorgan para obter um tipo aproximado ("float") em ferrugem estável e há uma resposta @ShubhamJain para obter um tipo preciso ("f64") através da função instável em ferrugem noturna.
Agora, aqui está uma maneira de obter um tipo preciso (ou seja, decidir entre f32 e f64) com ferrugem estável:
fn main() {
let a = 5.;
let _: () = unsafe { std::mem::transmute(a) };
}
resulta em
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
--> main.rs:3:27
|
3 | let _: () = unsafe { std::mem::transmute(a) };
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `f64` (64 bits)
= note: target type: `()` (0 bits)
Atualizar
A variação do peixe-boi
fn main() {
let a = 5.;
unsafe { std::mem::transmute::<_, ()>(a) }
}
é um pouco mais curto, mas um pouco menos legível.
float
, dizendo entre f32
e f64
pode ser realizado comstd::mem::size_of_val(&a)
Algumas outras respostas não funcionam, mas acho que a caixa de nomes de tipos funciona.
Crie um novo projeto:
cargo new test_typename
Modifique o Cargo.toml
[dependencies]
typename = "0.1.1"
Modifique seu código fonte
use typename::TypeName;
fn main() {
assert_eq!(String::type_name(), "std::string::String");
assert_eq!(Vec::<i32>::type_name(), "std::vec::Vec<i32>");
assert_eq!([0, 1, 2].type_name_of(), "[i32; 3]");
let a = 65u8;
let b = b'A';
let c = 65;
let d = 65i8;
let e = 65i32;
let f = 65u32;
let arr = [1,2,3,4,5];
let first = arr[0];
println!("type of a 65u8 {} is {}", a, a.type_name_of());
println!("type of b b'A' {} is {}", b, b.type_name_of());
println!("type of c 65 {} is {}", c, c.type_name_of());
println!("type of d 65i8 {} is {}", d, d.type_name_of());
println!("type of e 65i32 {} is {}", e, e.type_name_of());
println!("type of f 65u32 {} is {}", f, f.type_name_of());
println!("type of arr {:?} is {}", arr, arr.type_name_of());
println!("type of first {} is {}", first, first.type_name_of());
}
A saída é:
type of a 65u8 65 is u8
type of b b'A' 65 is u8
type of c 65 65 is i32
type of d 65i8 65 is i8
type of e 65i32 65 is i32
type of f 65u32 65 is u32
type of arr [1, 2, 3, 4, 5] is [i32; 5]
type of first 1 is i32
typename
não funciona com variáveis sem tipo explícito na declaração. Executá-lo com my_number
a partir da pergunta dá o seguinte erro "não pode chamar o método type_name_of
de tipo numérico ambígua {float}
ajuda: você deve especificar um tipo para essa ligação, como. f32
"
0.65
e funciona bem: type of c 0.65 0.65 is f64
. aqui está a minha versão:rustc 1.38.0-nightly (69656fa4c 2019-07-13)
Se você está apenas querendo saber o tipo de sua variável durante o desenvolvimento interativo, eu recomendo o uso de rls (rust language server) dentro do seu editor ou ide. Você pode simplesmente ativar ou alternar permanentemente a capacidade de passar o mouse e apenas colocar o cursor sobre a variável. Um pequeno diálogo deve apresentar informações sobre a variável, incluindo o tipo.
:?
já há muito tempo foi implementado manualmente. Mais importante, porém, astd::fmt::Debug
implementação (para isso é o que:?
usa) para tipos de número não inclui mais um sufixo para indicar de que tipo ele é.