Temperature calculator in Rust
use std::io;

fn main() {
    println!("Enter Temperature as 56f or 98c");

    let mut usr_inpt = String::new();

    io::stdin()
        .read_line(&amp;mut usr_inpt)
        .expect("can not read user input");



I like that you’re using expect here instead of unwrap. 
It allows for a much nicer user experience when things go sideways. 
If I was nitpicking, I’d remind you to use proper capitalization and punctuation. 


    let usr_inpt = usr_inpt.trim_end().to_lowercase();

    if usr_inpt.ends_with("f") || usr_inpt.ends_with("c") {
        // remove the last indication 56f -&gt; 56 or 56c -&gt; 56
        let _temp: String = usr_inpt.chars().take(usr_inpt.len() - 1).collect();



temp is rarely a good name. 
If you meant temperature instead of temporary, it would be good to spell it out. 


        let num: u32 = match _temp.parse() {
            Ok(num) =&gt; num,
            Err(_) =&gt; 0,
        };



Is it really the right thing to return zero in the error case?
I would expect the error case here to be caused by invalid user input (or a bug in your previous parsing logic maybe).
It would probably be best to alert the user to this failure instead of the slightly enigmatic result of 0. 


        if usr_inpt.ends_with("f") {
            println!("celcius -&gt; {}", (num - 32) * 5 / 9);
        } else if usr_inpt.ends_with("c") {
            println!("farenheit -&gt; {}", num * 9 / 5 + 32);
        }



It smells a little funny that we’re making the same checks again as we did above. If you extracted the parsing logic into a function, you could just call it for each case. I would probably also extract proper fahrenheit_to_celcius and celcius_to_fahrenheit functions. 


    } else {
        println!("invalid input");
    }
}



Error messages should be printed to stderr. 
Use the eprintln macro instead. 

———————

All in all it’s pretty good for a first go. 
I would take a look at using some types for Fahrenheit and Celsius though. Your parse method could return a Temperature that contains either a Celsius or Fahrenheit measurement. 

I’ve not run this through the compiler, but hopefully it illustrates the idea. 

struct Celsius { value: u32 }
impl Celsius {
    fn to_farhenheit(&amp;self) -&gt; Farhenheit {
        Fahrenheit { value: self.value * 9 / 5 + 32 }
    }
}

struct Fahrenheit { value: u32 }
impl Fahrenheit {
    fn to_celsius(&amp;self) -&gt; Celsius {
        Celsius { value: ( self.value  - 32) * 5 / 9 }
    }
}

enum Temperature {
    Fahrenheit(Fahrenheit),
    Celsius(Celsius)
    Err(String)
}

fn parse_input(input: &amp;str) -&gt; Temperature {
    if input.ends_with("f") {
        Fahrenheit { value: parse_num(input) }
    } else if input.ends_with(“c”) {
        Celsius { value: parse_num(input) }
    } else {
        Err(“Input invalid. Must end with ‘c’ or ‘f’.”)
    }
}

fn parse_num(input: &amp;str) -&gt; u32 {
    let temperature: String = usr_inpt.chars().take(usr_inpt.len() - 1).collect();

    match temperature.parse() {
        Ok(num) =&gt; num,
        Err(_) =&gt; 0,
    };
}


Then we tie it all together in main. 

fn main() {
    println!("Enter Temperature as 56f or 98c");

    let mut usr_inpt = String::new();

    io::stdin()
        .read_line(&amp;mut usr_inpt)
        .expect("can not read user input");

    let temperature = parse_input(usr_inpt.trim_end().to_lowercase());

    match temperature {
        Temperature::Celsius { celsius } =&gt; println!("celcius -&gt; {}", celcius.to_fahrenheit()),
        Temperature::Fahrenheit { fahrenheit } =&gt; println!(“fahrenheit -&gt; {}”, fahrenheit.to_celsius()),
        Err(reason) =&gt; eprintln!(reason)
    }
}


While it’s certainly more code, it raises the level of abstraction in your main function quite a bit. 


Greet user
Get input
Parse input
Write out results 


This also provides the opportunity (left as an exercise for the reader) to propagate errors from parse_num all the way back up to the user, rather than silently returning an invalid result.