unwrap and expect

Rust provides two methods for handling unrecoverable errors unwrap and expect, they can be used on both Result and Option types, they will trigger a panic! if the value is an Err(E) variant for Result<T, E> or a None variant for Option<T>

These methods extract the inner value but terminate the program if the operation fails. They are particularly useful for quick prototyping or situations where an error is truly unrecoverable.

In this challenge, you will interact with file operations to demonstrate the use of unwrap and expect. Instead of directly working with Result or Option, you will use standard library functions that return these types and handle their results using unwrap and expect.

Your Task

Implement the following functions:

read_file_to_string: This function takes a file path as input, attempts to read its contents, and returns the contents as a String. Use expect to handle any file I/O errors with a custom error message of exactly Failed to read file: <path>.
get_env_variable: This function retrieves the value of an environment variable by name. Use unwrap to panic if the variable is not set.

Notes

expect provides a way to add context to your panics, which can help with debugging.
unwrap is more concise but less descriptive when errors occur.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

Use std::fs::read_to_string(path) to read the contents of a file. It returns a Result<String, std::io::Error>.
Use std::env::var(key) to retrieve an environment variable. It returns a Result<String, std::env::VarError>.
Use .expect() to add a custom error message when handling a Result.
Use .unwrap() for a quick, less descriptive error handling method.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

/sam

samging

a day ago

6.01ms

90.67kb

use std::env;
use std::fs;
use std::fs::read_to_string;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Ari Karim

arikarim

3 days ago

7.51ms

90.67kb

use std::{fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut buf = "".to_string();
    let mut file = File::open(path).expect(format!("Failed to read file: {path}").as_str());
    file.read_to_string(&mut buf).expect(format!("Failed to read file: {path}").as_str());
    buf
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Yummy-Yums

4 days ago

5.71ms

90.67kb

 use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut file = std::fs::File::open(path).expect(format!("Failed to read file: {}", path).as_str());
    let mut contents = String::new();
    
    file.read_to_string(&mut contents);
    
    contents
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

xexid84

6 days ago

5.53ms

90.67kb

use std::fs;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Zisraw

8 days ago

6.04ms

91.26kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect("Failed to read file: {path}")
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Vincent SAMY

vsamy

9 days ago

5.15ms

90.67kb

use std::fs;
use std::io::Read;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    let mut f = fs::File::open(path).expect(&format!("Failed to read file: {}", path));
    let mut buffer = String::new();
    f.read_to_string(&mut buffer).expect(&format!("Failed to read file: {}", path));
    buffer
}
pub fn get_env_variable(key: &str) -> String {
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Yashwanth

Yash981

9 days ago

4.86ms

90.66kb

use std::fs;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    return fs::read_to_string(path).expect(&format!("Failed to read file: {}",path));
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    return std::env::var(key).unwrap();
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Yashwanth

Yash981

9 days ago

5.21ms

91.31kb

use std::fs;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    match fs::read_to_string(path){
        Ok(content) => content,
        Err(_)=> panic!("Failed to read file: {}",path)
    }
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    match std::env::var(key){
        Ok(url) => url,
        Err(_) => panic!("error reading env key")
    }
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

reborn3d

12 days ago

7.57ms

90.67kb


use std::fs::read_to_string;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    //let mut buf = BufReader::new(file);
    return read_to_string(path).expect(&format!("Failed to read file: {path}"));
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    return std::env::var(key).unwrap();
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

jfloresremar

14 days ago

6.80ms

91.32kb

use std::{env, fs::read_to_string};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    // read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
    read_to_string(path).unwrap_or_else(|_| panic!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Abhishek Sharma

0xAbhiDev

15 days ago

6.25ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
   std::fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
      std::env::var(key).unwrap() 
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

nojae15

15 days ago

5.01ms

90.67kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect(&format!("Failed to read file: {path}."))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

QuJohan

17 days ago

5.70ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect(format!("Failed to read file: {}", path).as_str())
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

SAMUEL-NOVAK

18 days ago

4.79ms

90.71kb

use std::fs::read_to_string;
use std::env::var;
pub fn read_file_to_string(path: &str) -> String {
    let possible_message = format!("Failed to read file: {}", path);
    let contents = read_to_string(path).expect(&format!("Failed to read file: {}", path));
    return contents;
}
pub fn get_env_variable(key: &str) -> String {
    let contents = var(key).unwrap();
    return contents;
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

wytsier

19 days ago

6.05ms

90.67kb

use std::fs;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let content = fs::read_to_string(path).expect(format!("Failed to read file: {}", path).as_str());
    content
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap() 
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

LS Koenig

ghoti225

20 days ago

5.53ms

90.67kb

use std::fs::File;
use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut file = File::open(path).expect(format!("Failed to read file: {}", path).as_str());
    
    let mut buffer = String::new();
    _ = file.read_to_string(&mut buffer);
    buffer
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap().to_string()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Omar

OmniKobra

21 days ago

9.25ms

90.67kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
  
     let s = std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str());
    s
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let var = std::env::var(key).unwrap();
    var
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Omar

OmniKobra

21 days ago

17.91ms

90.67kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
  
     let s = std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str());
    s
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let var = std::env::var(key).unwrap();
    var
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Francisco Alejandro

francisco-alejandro

22 days ago

5.05ms

90.54kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key.to_string()).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Abdul

aisiyoup

25 days ago

5.61ms

91.27kb

use std::fs::read_to_string;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut content = read_to_string(path).expect("Failed to read file: {path}");
    content
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let env = std::env::var(key).unwrap();
    env
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

kaazzziii

a month ago

4.23ms

91.26kb

use std::fs::{read_to_string, File};
pub fn read_file_to_string(path: &str) -> String {
    let contents = read_to_string(path).expect("Failed to read file: {path}");
    contents
}
pub fn get_env_variable(key: &str) -> String {
    let value = std::env::var(key).unwrap();
    value
}
// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

TheJanzap

a month ago

5.07ms

90.54kb

use std::{env, fs};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).expect(&format!("Missing environment variable {}", key))
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Denis Schüle

FaberDS

a month ago

5.66ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

msned

a month ago

5.01ms

90.66kb

use std::fs;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    let contents = std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str());
    return contents;
}
pub fn get_env_variable(key: &str) -> String {
    let var = std::env::var(key).unwrap();
    return var;
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Juan Mejia

juan-mejia

a month ago

5.46ms

90.67kb

use std::fs;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

jh4vision

a month ago

4.71ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Smith, Taylor

a647965_fidelity

a month ago

4.34ms

90.67kb

use std::fs;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

muemart

a month ago

5.99ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

muemart

a month ago

4.89ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    std::fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Christophe Mohimont

mohic

a month ago

5.07ms

91.32kb

use std::fs::File;
use std::io::{BufReader, Read};
pub fn read_file_to_string(path: &str) -> String {
    let mut file = File::open(path).unwrap_or_else(|_| panic!("Failed to read file: {path}"));
    let mut buffer = String::new();
    file.read_to_string(&mut buffer)
        .unwrap_or_else(|_| panic!("Failed to read file: {path}"));
    buffer
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}

ashishkr2912

a month ago

4.77ms

90.67kb

use std::fs::read_to_string;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    read_to_string(path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

amdfxlucas

a month ago

6.61ms

90.67kb

pub fn read_file_to_string(path: &str) -> String {
     std::fs::read_to_string(path).expect(format!("Failed to read file: {path}.").as_str())
}
pub fn get_env_variable(key: &str) -> String {
   std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

StevenCanDrink

a month ago

5.23ms

91.27kb

pub fn read_file_to_string(path: &str) -> String {
    match std::fs::read_to_string(path) {
        Ok(content) if !content.is_empty() => content,
        Ok(_) => "".to_string(),
        Err(_) => panic!("Failed to read file: {}", path),
    }
}
pub fn get_env_variable(key: &str) -> String {
    match std::env::var(key) {
        Ok(env) if !env.is_empty() => env,
        Ok(_) => "".to_string(),
        Err(_) => panic!(""),
    }
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

StevenCanDrink

a month ago

7.35ms

90.86kb

pub fn read_file_to_string(path: &str) -> String {
    match std::fs::read_to_string(path) {
        Ok(content) if !content.is_empty() => content,
        Ok(_) => "".to_string(), // Handle empty file case
        Err(_) => panic!("Failed to read file: {}", path), // Handle read error
    }
}
pub fn get_env_variable(key: &str) -> String {
    match std::env::var(key) {
        Ok(value) if !value.is_empty() => value,
        Ok(_) => "".to_string(), // Handle empty value
        Err(_) => panic!("Environment variable '{}' not found", key), // Handle missing key
    }
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Chih Ying Yen

xavierforge

2 months ago

5.67ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

undefeated_

boyboi86

2 months ago

6.19ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

GunGraveCpp

2 months ago

4.81ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
   std::fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

David Rasch

dcrasch

2 months ago

6.51ms

90.66kb

use std::fs::read_to_string;
use std::env;
pub fn read_file_to_string(file_path: &str) -> String {
    read_to_string(file_path).expect(format!("Failed to read file: {file_path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Lvfalue

2 months ago

4.85ms

90.67kb

use std::fs;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let content = fs::read_to_string(path)
        .expect(format!("Failed to read file: {path}").as_str());
    
    content
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Artem

artemnistuley

2 months ago

4.86ms

90.67kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let contents = std::fs::read_to_string(path)
        .expect(&format!("Failed to read file: {}", path));
    contents
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let v = std::env::var(key).unwrap();
    v
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Jean-baptiste JOFFRE

Indy79

2 months ago

5.71ms

90.67kb

use std::fs::File;
use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut buffer = String::new();
    File::open(path)
        .expect(&format!("Failed to read file: {path}"))
        .read_to_string(&mut buffer)
        .expect(&format!("Failed to read file: {path}"));
    buffer
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    std::env::var(key).unwrap()
}
/// Example usage
pub unsafe fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

toto

2 months ago

5.49ms

90.67kb

use std::{env, fs};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

visanr

2 months ago

5.71ms

90.66kb

use std::fs;
pub fn read_file_to_string(path: &str) -> String {
    fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
    // 1. Implement the function
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
    // 2. Implement the function
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Luka Bračun

lbracun

2 months ago

5.18ms

90.66kb

use std::fs;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
pub fn get_env_variable(key: &str) -> String {
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Tommy

verse215

2 months ago

6.17ms

90.67kb

use std::fs;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Jai

jsat97

2 months ago

4.56ms

90.67kb

use std::fs::File;
use std::io::Read;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let msg = format!("Failed to read file: {path}");
    let mut f = File::open(path).expect(&msg);
    let mut buf = String::new();
    f.read_to_string(&mut buf).expect(&msg);
    buf
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let env_var = env::var(key).unwrap();
    env_var
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

bzdula

2 months ago

4.85ms

90.66kb

pub fn read_file_to_string(path: &str) -> String {
    std::fs::read_to_string(path).expect(&format!("Failed to read file: {path}"))
    // 1. Implement the function
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Ranjith Thangavel

RanjithECE24

2 months ago

4.95ms

90.67kb

use std::fs::File;
use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    let mut file = File::open(path).expect(&format!("Failed to read file: {path}"));
    let mut buffer = String::new();
    file.read_to_string(&mut buffer).unwrap();
    buffer
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

Gurneet singh

GS-Jatt

2 months ago

5.44ms

91.75kb

use std::{env, fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut file = File::open(path).expect(&format!("Failed to read file:{path}"));
    let mut res = String::new();
    file.read_to_string(&mut res).unwrap();
    res
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}

shahab-tplus

2 months ago

9.81ms

90.67kb

use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::read_to_string(&path).expect(&format!("Failed to read file: {}", path))
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    env::var(key).unwrap()
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic
    read_file_to_string("nonexistent.txt");
    get_env_variable("MISSING_KEY");
}