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

muemart

3 hours 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

3 hours 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

2 days 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

6 days 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

6 days 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

7 days 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

7 days 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

9 days 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

11 days 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

14 days 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

15 days 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

16 days 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 Nistuley

artemnistuley

18 days 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

19 days 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

20 days 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

21 days 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

23 days 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

23 days 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

23 days 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

23 days 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

24 days 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

a month 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

a month 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");
}

shahab-tplus

a month ago

4.81ms

90.67kb

use std::env;
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
    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

a month ago

7.03ms

90.67kb

use std::env;
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));
    content
}
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");
}

Wouter

WouterMartens

a month ago

4.44ms

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()
}
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");
}

whhc

a month ago

5.61ms

90.67kb

use std::{fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    let mut file = File::open(path).expect(format!("Failed to read file: {path}").as_str());
    let mut buf = String::new();
    file.read_to_string(&mut buf).expect("Read file error");
    buf
}
pub fn get_env_variable(key: &str) -> String {
    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");
}

Daniel Mestas

miel-codeai

a month ago

5.63ms

90.67kb

use std::{fs::File, 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");
}

aghia98

a month ago

5.29ms

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).as_ref())
    
}
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");
}

baschdik

a month ago

5.36ms

90.67kb

use std::env;
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).as_ref())
}
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");
}

Evgenii Uglanov

winchest3r

a month ago

5.18ms

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");
}

thriller08

a month ago

5.33ms

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");
}

manu3618

a month ago

5.36ms

90.67kb

use std::io::*;
use std::fs::File;
    
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut content = String::new();
    let msg = format!("Failed to read file: {path}");
    let mut f = File::open(path).expect(&msg);
    f.read_to_string(&mut content).expect(&msg);
    content
}
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");
}

Marco Coccato

Ocrambana

a month ago

4.59ms

90.67kb

use std::io;
use std::io::prelude::*;
use std::fs::File;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let err = format!("Failed to read file: {}", path);
    let mut f = File::open(path).expect(err.as_ref());
    let mut buf : String = String::new();
    f.read_to_string(&mut buf).expect(err.as_ref());
    buf
}
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");
}

Fatih

0fatih

a month ago

6.13ms

90.67kb

use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let err = format!("Failed to read file: {path}");
    let mut f = std::fs::File::open(path).expect(err.as_ref());
    let mut b = String::new();
    f.read_to_string(&mut b);
    b
}
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");
}

Rose Emmons

roseemmons

a month ago

4.56ms

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: {0}", 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");
}

slaws

a month ago

5.88ms

90.67kb

use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut fd = std::fs::File::open(path).expect(format!("Failed to read file: {path}").as_str());
    let mut buff = String::new();
    fd.read_to_string(&mut buff).expect(format!("Failed to read file: {path}").as_str());
    buff
}
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");
}

Christopher Kolbe

chkolbe

a month ago

4.94ms

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: {0}", 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");
}

Evrins Hu

evrins

a month ago

5.10ms

98.33kb

use std::env;
use std::fs::File;
use std::io::{BufReader, Read};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let file = File::open(path).expect(format!("Failed to read file: {}", path).as_str());
    let mut reader = BufReader::new(file);
    let mut buf = String::new();
    reader.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
    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");
}

johndoe30bc

a month ago

4.62ms

90.67kb

use std::{fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    let io_err_msg = format!("Failed to read file: {path}");
    let mut f = File::open(path).expect(&io_err_msg);
    let file_len = f.metadata().expect(&io_err_msg).len() as usize;
    let mut buf = String::with_capacity(file_len);
    let n = f.read_to_string(&mut buf).expect(&io_err_msg);
    if n != file_len {
        panic!("{io_err_msg}");
    }
    buf
}
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");
}

Baron Curtin

baroncurtin2

a month ago

5.05ms

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).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");
}

tdoan

a month ago

4.66ms

91.32kb

pub fn read_file_to_string(path: &str) -> String {
    std::fs::read_to_string(path).unwrap_or_else(|_| panic!("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");
}

m1031

monorail103

a month ago

4.63ms

90.67kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let msg = format!("Failed to read file: {path}");
    let file = std::fs::read_to_string(path).expect(msg.as_str());
    file
}
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");
}

Evgenii Grigorenko

grevgeny

2 months ago

4.91ms

90.66kb

use std::{fs, env};
pub fn read_file_to_string(path: &str) -> String {
    fs::read_to_string(path).expect(format!("Failed to read 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");
}

Blaze

Divakar-2508

2 months ago

5.42ms

90.67kb

use std::{fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let error_msg = format!("Failed to read file: {path}");
    let mut file = File::open(path).expect(error_msg.as_str());
    let mut buffer = String::new();
    file.read_to_string(&mut buffer).expect(error_msg.as_str());
    buffer
}
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");
}

Procybit

2 months ago

5.10ms

90.67kb

use std::{env, fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    let mut f = File::open(&path).expect(format!("Failed to read file: {}", &path).as_str());
    let mut s = String::new();
    f.read_to_string(&mut s).expect(format!("Failed to read file: {}", &path).as_str());
    s
}
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");
}

FredoPo

2 months ago

5.33ms

90.67kb

use std::{fs::File, io::Read};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut f = File::open(path).expect(format!("Failed to read file: {path}").as_str());
    let mut buf= "".to_string();
    f.read_to_string(&mut buf).expect(format!("Failed to read file: {path}").as_str());
    buf.to_string()
}
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");
}

brucecox01

2 months ago

5.09ms

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");
}

Karol Płatkowski

spoohie

2 months ago

4.98ms

90.67kb

use std::io;
use std::fs::File;
pub fn read_file_to_string(path: &str) -> String {
    let error_msg = format!("Failed to read file: {path}");
    let f = File::open(path).expect(&error_msg);
    return io::read_to_string(f).expect(&error_msg);
}
pub fn get_env_variable(key: &str) -> String {
    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");
}

Krzysztof Atłasik

katlasik

2 months ago

5.85ms

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).expect(&format!("Failed to read file: {path}"));
  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");
}