Result 열거형

Result 열거형은 Option 열거형과 비슷하지만, Option 열거형은 Some과 None만을 가지고 있지만, Result 열거형은 Ok와 Err를 가지고 있습니다.

use std::fmt::Error;

fn give_ok_or_err(bool: bool) -> Result<String, Error> {
    if bool {
        Ok(String::from("💖"))
    } else {
        Err(Error)
    }
}

fn main() {
    for bool in [true, false].iter() {
        let result = give_ok_or_err(*bool);
        match result {
            Ok(value) => println!("value: {}", value),
            Err(e) => println!("error: {}", e),
        }
    }
}

Unwrap...

unwrap

use std::fmt::Error;

fn give_ok_or_err(bool: bool) -> Result<String, Error> {
    if bool {
        Ok(String::from("💖"))
    } else {
        Err(Error)
    }
}

fn main() {
    let result = give_ok_or_err(false).unwrap();
    println!("{}", result);
}

unwrap_or

unwrap_or는 Result<T, E>를 T로 변환합니다. 결과가 Ok(v)이면 v를 반환하고, Err(e)이면 인수를 반환합니다.

use std::fmt::Error;

fn give_ok_or_err(bool: bool) -> Result<String, Error> {
    if bool {
        Ok(String::from("💖"))
    } else {
        Err(Error)
    }
}

fn main() {
    let result = give_ok_or_err(false).unwrap_or(String::from("💔"));
    println!("{}", result);
}

ok_or...

ok_or와 ok_or_else는 Option를 Result<T, E>로 변환합니다.

ok_or

Option<T>를 Result<T, E>로 변환하여 일부(v)를 Ok(v)로, 없음(None)을 Err(err)로 매핑합니다.

ok_or에 전달된 인수는 즉시 평가되며, 함수 호출의 결과를 전달하는 경우 느리게 평가되는 ok_or_else를 사용하는 것이 좋습니다.

fn main() {
    let x = Some("foo");
    assert_eq!(x.ok_or(0), Ok("foo"));

    let x: Option<&str> = None;
    assert_eq!(x.ok_or(0), Err(0));
}

ok_or_else

Option<T>를 Result<T, E>`로 변환하여 일부(v)를 Ok(v)로, 없음을 Err(err())로 매핑합니다.

fn main() {
    let x = Some("foo");
    assert_eq!(x.ok_or_else(|| 0), Ok("foo"));

    let x: Option<&str> = None;
    assert_eq!(x.ok_or_else(|| 0), Err(0));
}

?

결과가 Ok 이 아닌 경우 즉시 함수를 종료하고 Err을 반환합니다.

use std::fmt::Error;

fn give_ok_or_err(bool: bool) -> Result<String, Error> {
    if bool {
        Ok(String::from("💖"))
    } else {
        Err(Error)
    }
}

fn question_mark(bool: bool) -> Result<String, Error> {
    let result = give_ok_or_err(bool)?;
    Ok(result)
}

fn main() {
    let result = question_mark(true);
    println!("{:?}", result);
    let result = question_mark(false);
    println!("{:?}", result);
}

커스텀 예외 정의하기

import os


def get_content():
    filepath = os.path.join(os.path.pardir, "test.txt")
    with open(filepath, "r") as f:
        return f.read()


class CustomError(Exception):
    pass


if __name__ == '__main__':
    try:
        with open("hello.txt", "r") as file:
            file.read()
    except FileNotFoundError as exc:
        print(exc)
    except:
        print("Unexpected error")

    try:
        content = get_content()
    except:
        raise CustomError
    print(content)

use std::fmt;
use std::fs::File;
use std::io::{Error, ErrorKind, Read};
use std::path::Path;

fn get_content() -> Result<String, Error> {
    let mut content = String::new();
    let filepath = Path::new(std::env::current_dir().unwrap().parent().unwrap()).join("test.txt");
    File::open(filepath)?.read_to_string(&mut content)?;
    Ok(content)
}

#[derive(Debug, Clone)]
struct CustomError;

impl fmt::Display for CustomError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "File not found!")
    }
}

fn main() {
    let file = File::open("hello.txt");
    match file {
        Ok(file) => println!("{:?}", file),
        Err(error) => match error.kind() {
            ErrorKind::NotFound => println!("{:?}", error),
            _ => println!("Unexpected error"),
        },
    }

    let content = get_content().unwrap_or_else(|_| {
        panic!("{}", CustomError);
    });
    println!("{}", content);
}