OS 2023 学习记录

let entry_mut_ref  = map.entry(key).or_insert(init);

"bar".repeat(n);

use std::num::ParseIntError;

// This is a custom error type that we will be using in `parse_pos_nonzero()`.
#[derive(PartialEq, Debug)]
enum ParsePosNonzeroError {
    Creation(CreationError),
    ParseInt(ParseIntError)
}

impl ParsePosNonzeroError {
    fn from_creation(err: CreationError) -> ParsePosNonzeroError { // <<====
        ParsePosNonzeroError::Creation(err)
    }
    // TODO: add another error conversion function here.
    fn from_parseint(err: ParseIntError) -> ParsePosNonzeroError {// <<====
        ParsePosNonzeroError::ParseInt(err)
    }
}

fn parse_pos_nonzero(s: &str)
    -> Result<PositiveNonzeroInteger, ParsePosNonzeroError>
{
    // TODO: change this to return an appropriate error instead of panicking
    // when `parse()` returns an error.
    let x: i64 = s.parse().map_err(ParsePosNonzeroError::from_parseint)?; // <<====
    PositiveNonzeroInteger::new(x)
        .map_err(ParsePosNonzeroError::from_creation)// <<====
}

// Don't change anything below this line.

#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);

#[derive(PartialEq, Debug)]
enum CreationError {
    Negative,
    Zero,
}

impl PositiveNonzeroInteger {
    fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {// <<====
        match value {
            x if x < 0 => Err(CreationError::Negative),
            x if x == 0 => Err(CreationError::Zero),
            x => Ok(PositiveNonzeroInteger(x as u64))
        }
    }
}

fn some_func(item: impl SomeTrait +  OtherTrait ) -> bool {

/// "hello" -> "Hello"
pub fn capitalize_first(input: &str) -> String {
    let mut c = input.chars();
    match c.next() {
        None => String::new(),
        Some(first) => first.to_uppercase().chain(c).collect()
    }
}

/// ["hello", " ", "world"] -> "Hello World"
pub fn capitalize_words_string(words: &[&str]) -> String {
    words.iter().map(|w| capitalize_first(w))
        .fold("".to_string(), | mut acc,cur |{acc.push_str(&cur);acc })

}

/// Clone : &T -> T
/// ToOwned是Clone的泛化版本.而不是仅仅能从 &T 得到 T
/// 通常是用于将同种语义的类型,但一个是变长类型(heap上分配), 另一个是定长类型的(stack上分配),
/// 用来将stack上分配的类型转为heap上分配的类型.
pub trait ToOwned {
    type Owned: Borrow<Self>; // 这个Owned类型必须能产生.borrow()Self类型的(不可变)借用

    // Required method
    fn to_owned(&self) -> Self::Owned;

    // Provided method
    fn clone_into(&self, target: &mut Self::Owned) { ... }
}

pub trait Borrow<Borrowed>
where
    Borrowed: ?Sized,
{
    // Required method
    fn borrow(&self) -> &Borrowed;
}

impl FromStr for Person {
    type Err = ParsePersonError;
    fn from_str(s: &str) -> Result<Person, Self::Err> {
        if s.len() == 0 {
            return Err(ParsePersonError::Empty);
        }
        let v : Vec<_> = s.split(',').collect();
        if v.len() != 2 {
            return Err(ParsePersonError::BadLen);
        }
        if v[0].len() == 0 {
            return Err(ParsePersonError::NoName);
        }
        let age = v[1].parse::<usize>()
            .map_err(ParsePersonError::ParseInt)?;

        Ok(Person{
            name : v[0].to_string(),
            age ,
        })

    }
}

impl TryFrom<(i16, i16, i16)> for Color {
    type Error = IntoColorError;
    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {


        if tuple.0 > 255 || tuple.0 < 0 {
            return Err(Self::Error::IntConversion);
        }
        if tuple.1 > 255 || tuple.1 < 0 {
            return Err(Self::Error::IntConversion);
        }
        if tuple.2 > 255 || tuple.2 < 0 {
            return Err(Self::Error::IntConversion);
        }               

        Ok(Color {
            red : tuple.0 as u8,
            green : tuple.1 as u8,
            blue: tuple.2 as u8,
        })
    }
}