p_rust 0.1.0

use std::{io};
use std::collections::HashMap;

type TemperatureFn = fn(f64) -> f64;
const TEMPERATURE_TYPE: &'static [&'static str] = &["", "Celsius", "Fahrenheit"];
const COUNTER_TEMPERATURE_TYPE: &'static [&'static str] = &["", "Fahrenheit", "Celsius"];

fn get_temperature_type_input() -> (&'static str, usize) {
    let temperature_type_input: usize = loop {
        let mut temperature_type_input_str = String::new();
        println!("1. Celsius\n2. Fahrenheit\nSelect temperature type:");
        io::stdin()
            .read_line(&mut temperature_type_input_str)
            .expect("Failed to read line");
        match temperature_type_input_str.trim().parse() {
            Ok(input_number) => {
                if input_number < 1 || input_number > TEMPERATURE_TYPE.len() {
                    println!("Invalid temperature type: {}", temperature_type_input_str);
                } else {
                    break input_number;
                }
            }
            Err(_) => {
                println!("Invalid temperature type: {}", temperature_type_input_str);
            }
        }
    };
    (TEMPERATURE_TYPE[temperature_type_input], temperature_type_input)
}

fn get_temperature_input() -> f64 {
    loop {
        let mut temperature_input_str = String::new();
        println!("\nEnter temperature number:");
        io::stdin()
            .read_line(&mut temperature_input_str)
            .expect("Failed to read line");
        match temperature_input_str.trim().parse() {
            Ok(input_number) => {
                break input_number;
            }
            Err(_) => {
                println!("Invalid temperature number: {}", temperature_input_str);
            }
        }
    }
}

fn celsius_to_fahrenheit(celsius: f64) -> f64 {
    let result: f64 = celsius * 1.8 + 32.0;
    (result * 10.0).round() / 10.0
}

fn fahrenheit_to_celsius(fahrenheit: f64) -> f64 {
    let result: f64 = (fahrenheit - 32.0) * 5.0 / 9.0;
    (result * 100.0).round() / 100.0
}

fn init() -> HashMap<&'static str, TemperatureFn> {
    let mut fn_map: HashMap<&str, TemperatureFn> = HashMap::new();
    fn_map.insert(&TEMPERATURE_TYPE[1], celsius_to_fahrenheit);
    fn_map.insert(&TEMPERATURE_TYPE[2], fahrenheit_to_celsius);
    fn_map
}

fn main() {
    let fn_map = init();

    let (temperature_type, temperature_type_int) = get_temperature_type_input();
    println!("Selected temperature type: {}", temperature_type);

    let temperature = get_temperature_input();
    println!("Input {}: {}", temperature_type, temperature);

    let temperature_fn = fn_map.get(temperature_type).unwrap();
    println!("Converted {}: {}", COUNTER_TEMPERATURE_TYPE[temperature_type_int], temperature_fn(temperature));
}