Пора задать жару всяким питонщикам и шарпистам

use std::fs;
use std::env;
use std::io::{self, prelude::*};
use std::collections::HashMap;
 
fn clean_out_word(word: &str) -> String {
   let clean_word = word.chars().filter(|&c| char::is_alphabetic(c) || char::is_numeric(c)).collect::<String>();
   clean_word.to_lowercase()
  
}
 
//передаём в эту функцию нашу строку в которую вы ранее считали файл
fn flood_hash(buffer: &String, hash: &mut HashMap<String, u16>) { 
    for line in buffer.lines() {  //разбиваем строку на подстроки с помощью метода lines
      for word in line.split_whitespace() {   //разбиваем подстроки на слова с помощью метода split_whitespace
        let clean_word = clean_out_word(word);
        if clean_word.len() > 0 {
          let counter = hash.entry(clean_word.to_string()).or_insert(0);
          *counter += 1;
        } 
      }
    }    
  }
 
 
fn sort_hash(hash: HashMap<String, u16>) -> Vec<(String, u16)> {
    let mut vhash: Vec<(String, u16)> = hash.into_iter().collect();
    vhash.sort_by(|a, b| b.1.cmp(&a.1));
    vhash
 }
 
fn printout_vhash(hash: &Vec<(String, u16)>) {
    let mut counter = 1;
    
    for (key, value) in hash {
      println!("{}) {} {}", counter, key, value);
      counter += 1;
    }
 }
 
fn main() -> () {
    
    let args = env::args().collect::<Vec<String>>();
    let args_len = args.len();
 
    if args_len < 2 || args_len > 2 {
       eprintln!("USAGE: {} filename", args[0]);
       return ()  
    }
  
    let buffer: String = fs::read_to_string(&args[1]).unwrap();  //читаем весь файл в строку
    let buffer_len = buffer.len();
    
    if buffer_len == 0 {
        eprintln!("File is empty");
        return ()
    } else if buffer_len == 1 {
        println!("{} {}", buffer, 1);
        return ()
    } else if buffer_len == 2 {
        let temporary = buffer.split_whitespace().collect::<Vec<&str>>();
          if temporary[0] == temporary[1] {
             println!("{} {}", temporary[0], 2);
             return (); 
         } else {
             println!("{} {}", temporary[0], 1);
             println!("{} {}", temporary[1], 1);
             return ();
       }
    }
    
    let mut hash: HashMap<String, u16> = HashMap::new();
    
    if buffer_len >= 5000 {
      let mesg = "...программа выполняется..\n".as_bytes();
      let mut stderr = io::stderr();
      stderr.write(&mesg).expect("Немогу записать mesg в stderr");
      
    }
 
    
    flood_hash(&buffer, &mut hash);
    let vhash = sort_hash(hash); 
    printout_vhash(&vhash);
 
 
}