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

Pranav Garg

PranavGarg01

a day ago

8.75ms

90.55kb

use std::fs;
use std::env;
// 1. Function to read a file to a String
pub fn read_file_to_string(path: &str) -> String {
    // Attempt to read the file and handle errors with a custom message
    fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
// 2. Function to get an environment variable
pub fn get_env_variable(key: &str) -> String {
    // Attempt to get the environment variable and panic if it's not set
    env::var(key).expect(&format!("Environment variable '{}' is not set", key))
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    // Assuming "example.txt" exists and contains some text
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    // Set an environment variable for demonstration
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic: Attempt to read a non-existent file
    read_file_to_string("nonexistent.txt");
    // Must panic: Attempt to get a non-existent environment variable
    get_env_variable("MISSING_KEY");
}

AKA.MoneyTaker

M4Bo2

2 days ago

5.13ms

90.55kb

use std::fs;
use std::env;
// 1. Function to read a file to a String
pub fn read_file_to_string(path: &str) -> String {
    // Attempt to read the file and handle errors with a custom message
    fs::read_to_string(path).expect(&format!("Failed to read file: {}", path))
}
// 2. Function to get an environment variable
pub fn get_env_variable(key: &str) -> String {
    // Attempt to get the environment variable and panic if it's not set
    env::var(key).expect(&format!("Environment variable '{}' is not set", key))
}
/// Example usage
pub fn main() {
    // Example 1: Using read_file_to_string
    // Assuming "example.txt" exists and contains some text
    let file_content = read_file_to_string("example.txt");
    println!("File content: {}", file_content);
    // Example 2: Using get_env_variable
    // Set an environment variable for demonstration
    std::env::set_var("EXAMPLE_KEY", "example_value");
    let value = get_env_variable("EXAMPLE_KEY");
    println!("Environment variable value: {}", value);
    // Must panic: Attempt to read a non-existent file
    read_file_to_string("nonexistent.txt");
    // Must panic: Attempt to get a non-existent environment variable
    get_env_variable("MISSING_KEY");
}

Sandeep chauhan

ryzen-xp

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

amaneru

7ma8no9

2 days ago

4.87ms

90.67kb

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

Prafful

iamsahu

4 days ago

5.40ms

90.67kb

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

Diego Maia

diegocmsantos

6 days ago

4.87ms

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

Anıl Şenay

anilsenay

6 days ago

5.15ms

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

rado31

6 days ago

4.75ms

90.67kb

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

Dyaa Adel

dyaa-adel

7 days ago

6.92ms

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

TiagONTOP

8 days ago

4.65ms

90.64kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let message = format!("Failed to read file: {}", path);
    let content = std::fs::read_to_string(path).expect(&message);
    content
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let env_var = std::env::var(key).ok().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");
}

Yi Hao

leongyihao

8 days ago

5.95ms

91.26kb

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

Lê Minh Quân

aleister1102

8 days ago

4.42ms

90.67kb

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

manuelmj

8 days ago

6.96ms

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

Guilherme Cesário Strachan

strachan

9 days ago

4.39ms

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

Muhammad-Dennis

9 days ago

4.46ms

90.67kb

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

norabbito

10 days ago

5.38ms

90.67kb

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

tzmijewski

10 days ago

6.00ms

90.22kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    match std::fs::File::open(path.to_string()).ok() {
        Some(_) => std::fs::read_to_string(path.to_string()).unwrap(),
        _ => panic!("Failed to read file: {}", path.to_string())
    }
    
}
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");
}

Ayushman Rathore

Spartan09

10 days ago

5.09ms

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

Suraj Vijayan

its-me-sv

12 days ago

4.92ms

90.66kb

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

Suraj Vijayan

its-me-sv

12 days ago

5.25ms

91.37kb

pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    std::fs::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
    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");
}

Jordan

Jordan-Haidee

12 days ago

5.93ms

90.67kb

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

Jun Huang

leemars

13 days ago

4.64ms

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

Kyle Diaz

kylediaz

14 days ago

4.91ms

90.66kb

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

Kenneth Love

kennethlove

15 days ago

5.27ms

98.33kb

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

Marco-Normal

17 days ago

6.58ms

90.67kb

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

ludovicknecht

17 days ago

7.23ms

90.64kb

use std::fs::{read_to_string};
pub fn read_file_to_string(path: &str) -> String {
    read_to_string(&path).expect(format!("Failed to read file: {path}").as_str())
}
pub fn get_env_variable(key: &str) -> String {
    std::env::var_os(key).unwrap().to_string_lossy().into_owned()
}

Denis SOURON

Brack0

17 days ago

4.92ms

90.66kb

use std::{env::var, fs::read_to_string};
pub fn read_file_to_string(path: &str) -> String {
    read_to_string(path).expect(&format!("Failed to read file: {path}"))
}
pub fn get_env_variable(key: &str) -> String {
    var(key).unwrap()
}

Kentaro Abe

abekem

18 days ago

5.31ms

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

alemack17

18 days ago

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

Romain Grimau

Herrgrim0

18 days ago

5.29ms

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

Viktor Merkurev

fennr

18 days ago

8.32ms

90.54kb

use std::fs;
use std::env;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let data = fs::read_to_string(path).expect(format!("Failed to read file: {path}").as_str());
    data
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let data = env::var(key).expect(format!("Missing environment variable {}", key).as_str());
    data
}
/// 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");
}

Whisper_icoma

1378046967

19 days ago

5.07ms

90.54kb

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).expect(&format!("Environment variable {key} is not set"))
}
/// 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");
}

RiyadDz22

19 days ago

5.62ms

90.54kb

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).expect(&format!("Environment variable {key} is not set"))
}
/// 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");
}

kosay

sarub0b0

19 days ago

5.71ms

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

automata-studio

20 days ago

5.30ms

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

TeDeMos

21 days ago

4.51ms

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

rawar089

21 days ago

4.68ms

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

Algorab

21 days ago

5.99ms

90.66kb

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

iamforgettable

22 days ago

8.17ms

90.67kb

use std::{env, fs};
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function    contents
    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");
}

Nikita Smirnov

Nismirno

22 days ago

5.70ms

91.32kb

use std::{fs::File, io::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 buf = String::new();
    file.read_to_string(&mut buf).unwrap();
    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");
}

Elliott Draper

ejdraper

23 days ago

16.82ms

90.66kb

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

Justin Maillet

justy777

23 days ago

4.59ms

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

Simon Noetzlin

sainoe

23 days ago

5.87ms

90.33kb

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

Simon Noetzlin

sainoe

23 days ago

9.25ms

90.33kb

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

Jim Lawton

jimlawton

24 days ago

9.39ms

90.66kb

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

Stefan Roas

sroas

24 days ago

7.28ms

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

Shafer Hess

shafer-hess

25 days ago

4.90ms

98.33kb

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

Oebelus

oebelus

25 days ago

5.56ms

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

Jonathan Voss

jvoss

a month ago

5.30ms

90.67kb

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

TaiPoole

a month ago

4.81ms

90.67kb

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