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

xxxxsk

5 hours ago

4.79ms

90.67kb

use std::fmt::format;
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");
}

Herman effendi

hrmneffdii

16 hours ago

5.64ms

90.66kb

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

coreyralph

2 days ago

5.67ms

90.67kb

//use std::io;
use std::io::prelude::*;
use std::fs::File;
use std::env;
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 buffer = String::new();
    f.read_to_string(&mut buffer).expect(format!("Failed to read file: {path}").as_str());
    return 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");
}

alexsavio

2 days ago

4.74ms

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

Ushakov Andrey

stdstring

4 days ago

4.60ms

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

Philippe Massicotte

PMassicotte

4 days ago

5.74ms

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

vanos001

4 days ago

5.10ms

90.66kb

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

Kr0wZ

6 days ago

4.87ms

98.29kb

use std::fs::File;
use std::io::{BufRead, BufReader};
use std::io;
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));
    let reader = BufReader::new(file);
    io::read_to_string(reader).unwrap()
}
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");
}

esl

esl07

7 days ago

5.66ms

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

Enes

enesscevik

9 days ago

5.34ms

90.67kb

use std::io::Read;
pub fn read_file_to_string(path: &str) -> String {
    // 1. Implement the function
    let mut buf = String::new();
    let mut file = std::fs::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
    let var = std::env::var(key).unwrap();
    var.to_owned()
}
/// 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");
}

0x0f1

Paul4673

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

Luigi Terrone

LuigiTer

9 days ago

5.18ms

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

Heino Mortensen

hmortensen83

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

ikatlinsky

17 days ago

4.89ms

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

jbrakmic

18 days ago

5.30ms

90.67kb

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

diucicd

22 days ago

4.93ms

90.66kb

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

ycgw

23 days ago

6.17ms

91.27kb

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

Sergey Matyash

matiaspub

25 days ago

4.66ms

90.66kb

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

AQian

AQian0

a month ago

5.29ms

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

LeonardoPinheiro23

a month ago

4.64ms

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

Seth Wood

seth-wood

a month ago

5.44ms

90.59kb

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

Tengz Mao

MaoX-Yu

a month ago

6.01ms

90.93kb

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

Tommytto

a month ago

6.86ms

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

Erik Hollembeak

futureperfect

a month ago

7.80ms

90.67kb

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

sjmellor

a month ago

6.15ms

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 mut file = File::open(path).expect(format!("Failed to read file: {}", path).as_str());
    let mut contents = String::new();
    file.read_to_string(&mut contents).expect(format!("Failed to read file: {}", path).as_str());
    contents
}
pub fn get_env_variable(key: &str) -> String {
    // 2. Implement the function
    let var = 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");
}

whhc

a month ago

5.24ms

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

Zeno

djeanql

a month ago

4.91ms

90.67kb

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

Holger Knauer

hknauer

a month ago

4.95ms

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

ggnne

a month ago

5.30ms

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

ggnne

a month ago

4.72ms

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 mut file = File::open(path).expect(&format!("Failed to read file: {path}"));
    let mut content = String::new();
    file.read_to_string(&mut content).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");
}

zirkzee77

a month ago

5.90ms

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

Neel Knight

NeelKnight

2 months ago

7.42ms

90.66kb

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

Kanak Shilledar

kanakshilledar

2 months ago

5.64ms

91.26kb

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

zazapalm3012

2 months ago

5.75ms

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

Maintain

duonghb53

2 months ago

8.14ms

90.33kb

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

Maintain

duonghb53

2 months ago

7.71ms

90.28kb

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

Nicolai

Posmac

2 months ago

8.83ms

90.66kb

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

Léa Narzis

lean-apple

2 months ago

6.05ms

90.67kb

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

Health-Care-Movie

2 months ago

6.46ms

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

Health-Care-Movie

2 months ago

5.79ms

90.66kb

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

Elizabeth Doughty

Thymelizabeth

2 months ago

6.82ms

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

Splatrac

splatrac

2 months ago

5.28ms

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

Trịnh Chấn Duy

Duyyy123

2 months ago

10.60ms

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 file = File::open(path).expect(&format!("Failed to read file: {}", path));
    let mut buf = String::new();
    file.read_to_string(&mut buf)
        .expect(&format!("Failed to read file: {}", path));
    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");
}

Liyqq

2 months ago

6.67ms

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

agamaontherock

2 months ago

4.66ms

90.67kb

use std::fs::File;
use std::io::prelude::*;
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 contents = String::new();
    file.read_to_string(&mut contents).expect(format!("Failed to read file: {path}").as_str());
    return contents;
    
}
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");
}

Franklin Chen

FranklinChen

2 months ago

5.32ms

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

Nathan GAUD

Natchica

2 months ago

7.06ms

90.66kb

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

Nguyen Vo Hoang Son

sonmessia

2 months ago

5.76ms

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 result = String::new();
    file.read_to_string(&mut result).expect(format!("Failse to read file: {}", path).as_str());
    result
}
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");
}

Paolo Cancedda

Pac72

2 months ago

5.32ms

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 file = File::open(path).expect(format!("Failed to read file: {path}").as_str());
    let mut buffer = String::new();
    file.read_to_string(&mut buffer).expect(format!("Failed to read file: {path}").as_str());
    buffer
}
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");
}

roboquaternion

2 months ago

8.16ms

90.54kb

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