Advanced Match Patterns

Pattern matching in Rust is a powerful feature that allows you to destructure and inspect complex data types in a concise and readable manner. By using match statements, you can handle different variants of enums, tuples, and other data structures, applying specific logic based on the shape and content of the data.

This challenge will help you practice advanced pattern matching techniques in a real-world scenario.

Your Task

You need to implement a method check_validity(&self) for the BookItem enum that returns a bool indicating whether the item is valid based on the following rules:

Book:
- The number of pages must be greater than 0.
- If there is a discount:
  - Must be non-negative (≥ 0)
  - Must not exceed 50% (≤ 50)
EBook:
- The title (a String) must be non-empty.
- The second field in the tuple must be greater than 0.
Collection:
- Must not be empty
- ALL items in the collection must be valid
- This means a collection containing even one invalid item is considered invalid
OutOfPrint:
- This variant is always considered invalid.

Requirements

Implement check_validity(&self) using match guards to reflect these rules.
Return a boolean (true or false) based on the type of BookItem.
Ensure that the function does not panic for any valid input.

Hints

Click here to reveal hints

Use if guards to combine multiple conditions: if *pages > 0 && *d >= 0
Pattern match on Option<i32> using Some(d) and None
For Collections:
- Check !items.is_empty() first
- Use iter().all(|item| item.check_validity()) to ensure all items are valid
Remember to dereference numbers when using them in guards: *pages, *second
The catch-all _ => false arm handles any remaining invalid cases

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Chih Ying Yen

xavierforge

2 days ago

4.16ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book{ pages, discount } => {
                *pages > 0 && match discount {
                    Some(discount) => *discount >= 0 && *discount <= 50,
                    None => true
                }
            },
            Self::EBook(title, (_, second)) => {
                !title.is_empty() && *second > 0
            },
            Self::Collection(collection) => {
                !collection.is_empty() && collection.iter().all(|item| item.check_validity())
            },
            _ => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

undefeated_

boyboi86

3 days ago

4.91ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    // any comparison requires destruct 
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book{pages, discount} => {
                 *pages > 0 && match discount {
                    Some(d) => *d > 0 && *d < 50,
                    None => true
                } 
            },
            BookItem::EBook(title, (_, field2)) => {!title.is_empty() && *field2 > 0},
            BookItem::Collection(vec) => { !vec.is_empty() && vec.iter().all(|a| a.check_validity())},
            _ => false
            
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

amdfxlucas

4 days ago

5.13ms

90.58kb

#[derive(Debug,Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
   pub fn check_validity(&self) -> bool {
    match self{
        BookItem::Book{pages,discount} if *pages>0 && discount.is_none() => true,
        BookItem::Book{pages: pages, discount: Some(disc)} if *pages>0 && *disc>=0 && *disc<=50 => true,
        BookItem::EBook(title, (_,v)) if !title.is_empty() && *v>0 => true,
        BookItem::Collection(vec) if !vec.is_empty() && vec.iter().map(|x| if x.check_validity() {1}else{0}).sum::<usize>() == vec.len() => true,
        _ => false
    }
   }
   }
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

GunGraveCpp

7 days ago

5.78ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool{
        match self {
            BookItem::Book { pages, discount } => match (pages, discount) {
                (1.., Some(0..=50) | None) => true,
                _ => false
            },
            BookItem::EBook(title, (first, second) ) => match (title.len(), first, second) {
                (1.., _ , 1..) => true,
                _ => false
            },
            BookItem::Collection(collection) => match (collection.len(), collection.iter().all(|x| x.check_validity()) ) {
                (1.., true) => true,
                _ => false
            },
            BookItem::OutOfPrint => false,
        }
    } 
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

toto

8 days ago

4.51ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::OutOfPrint => false,
            Self::Collection(list)
                if list.is_empty() || !list.iter().all(|book| book.check_validity()) =>
            {
                false
            }
            Self::EBook(title, tuple) if title.is_empty() || tuple.0 <= 0 || tuple.1 <= 0 => false,
            Self::Book { pages, discount }
                if *pages <= 0
                    || discount.is_some_and(|discount| discount <= 0 || discount > 50) =>
            {
                false
            }
            _ => true,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Lvfalue

12 days ago

7.88ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                *pages > 0 && if let Some(discount) = discount {
                    *discount >= 0 && *discount <= 50
                } else {
                    true
                }
            },
            BookItem::EBook(title, (a, b)) => {
                !title.is_empty() && *a > 0 && *b > 0
            },
            BookItem::Collection(books) => {
                !books.is_empty() && books.iter().all(|book| book.check_validity())
            },
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

manu3618

13 days ago

5.20ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match &self {
            BookItem::Book{ pages: p, discount: _} if *p < 0 => false,
            BookItem::Book{ pages: _, discount: Some(d)} if *d >= 0 && *d <= 50 => true,
            BookItem::Book{ pages: _, discount: None} => true,            
            BookItem::EBook(s, (_, p)) if s.len() > 0 && *p > 0 => true,
            BookItem::Collection(v) if v.is_empty() => false,
            BookItem::Collection(v) if v.iter().all(|b|b.check_validity()) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

AtlasVakyrie

20 days ago

4.15ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book {pages, discount: None } if (*pages > 0) => true,
            BookItem::Book {pages, discount: Some(discount)} if (*pages > 0) & (*discount >= 0) & (*discount <=50) => true,
            BookItem::EBook (s, (_, b)) if !s.is_empty() & (*b > 0) => true,
            BookItem::Collection(book_items) if !(book_items.is_empty())  => book_items.iter().all(|b| b.check_validity()),
            BookItem::OutOfPrint => false,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

bzdula

22 days ago

4.29ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match &self {
            BookItem::Book { pages, discount } => {
                *pages > 0 && discount.map_or(true, |discount| discount >= 0 && discount <= 50)
            }
            BookItem::EBook(title, (_, t)) => !title.is_empty() && *t > 0,
            BookItem::Collection(book_items) => {
                !(book_items.is_empty() || book_items.iter().any(|item| !item.check_validity()))
            }
            BookItem::OutOfPrint => false,
        }
    }
    // TODO: Finish the implementation
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Wouter

WouterMartens

a month ago

6.31ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book{ pages, discount } => {
                *pages > 0 && discount.map_or(true, |d| d >= 0 && d <= 50)
            },
            BookItem::EBook(title, (_, page_count)) => {
                !title.is_empty() && *page_count > 0
            },
            BookItem::Collection(books) => {
                !(books.is_empty() || books.iter().any(|book| !book.check_validity()))
            },
            BookItem::OutOfPrint => false,
        }
    }
}
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Daniel Mestas

miel-codeai

a month ago

4.16ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                let discount = match discount {
                    Some(d) => *d >= 0 && *d <= 50,
                    None => true,
                };
                *pages > 0 && discount
            }
            BookItem::EBook(title, (num1, num2)) => !title.is_empty() && *num1 > 0 && *num2 > 0,
            BookItem::Collection(book_items) => {
                !book_items.is_empty() && book_items.iter().all(|book| book.check_validity())
            }
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

whhc

a month ago

4.48ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        let mut validity = true;
        match &self {
            BookItem::Book { pages, discount } => {
                if *pages < 0 {
                    validity = false;
                }
                if let Some(count) = *discount {
                    if count > 50 || count < 0 {
                        validity = false;
                    }
                }
            }
            BookItem::EBook(title, (m, n)) => {
                if title.is_empty() || *m <= 0 || *n <= 0 {
                    validity = false;
                }
            }
            BookItem::Collection(list) => {
                if list.is_empty() {
                    validity = false;
                }
                list.iter().for_each(|item| {
                    if !item.check_validity() {
                        validity = false;
                    }
                });
            }
            BookItem::OutOfPrint => {
                validity = false;
            }
        }
        validity
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Baron Curtin

baroncurtin2

a month ago

4.33ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                if *pages <= 0 {
                    return false;
                }
                // check discount validity if present
                match discount {
                    Some(discount_value) => {
                        *discount_value >= 0 && *discount_value <= 50
                    }
                    None => true, // no discount is valid
                }
            }
            
            BookItem::EBook(title, (_, second_field)) => {
                !title.is_empty() && *second_field > 0
            }
            
            BookItem::Collection(items) => {
                !items.is_empty() && items.iter().all(|item| item.check_validity())
            }
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Evrins Hu

evrins

a month ago

5.39ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                if *pages <= 0 {
                    return false;
                }
                if let Some(discount) = discount {
                    if *discount < 0 || *discount > 50 {
                        return false;
                    }
                }
                true
            }
            BookItem::EBook(title, (a, b)) => {
                if title.is_empty() {
                    return false;
                }
                if *a <= 0 || *b <= 0 {
                    return false;
                }
                true
            }
            BookItem::Collection(books) => {
                if books.is_empty() {
                    return false;
                }
                books.iter().all(|book| book.check_validity())
            }
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

medzernik

a month ago

4.49ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
           Self::Book{pages, discount} 
                if *pages > 0 && if discount.is_some() {
                  discount.unwrap() >= 0 && discount.unwrap() <= 50  
                } else {
                    discount.is_none()
                }
                => true,
           Self::EBook(name, (a, b)) if !name.is_empty() && *b > 0 => true,
           Self::Collection(items) if !items.is_empty() && items.iter().all(|x| x.check_validity()) => true,
           _ => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

johndoe30bc

a month ago

5.49ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                *pages > 0
                    && match discount {
                        Some(discount) => *discount >= 0 && *discount <= 50,
                        None => true,
                    }
            }
            BookItem::EBook(title, (_, second)) => !title.is_empty() && *second > 0,
            BookItem::Collection(book_items) => {
                !book_items.is_empty() && book_items.iter().all(|x| x.check_validity())
            }
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Miguel Ángel Allende

maallende

a month ago

5.80ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool{
        match self {
            BookItem::Book { pages, discount } => *pages > 0 && discount.map_or(true, |d| d <= 50 && d >= 0),
            BookItem::EBook(title, (_x, y)) => !title.is_empty() && *y > 0,
            BookItem::Collection(items) => !items.is_empty() && items.iter().all(|item| item.check_validity()),            
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Miguel Ángel Allende

maallende

a month ago

4.31ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool{
        match self {
            BookItem::Book { pages, discount } => *pages > 0 && discount.map_or(true, |d| d <= 50 && d >= 0),
            BookItem::EBook(title, (_x, y)) => !title.is_empty() && *y > 0,
            BookItem::Collection(items) => !items.is_empty() && items.iter().all(|item| item.check_validity()),            
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

FredoPo

a month ago

5.21ms

90.58kb

#[derive(Clone, Debug)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages,  discount} => *pages > 0 && ((*discount >= Some(0) && *discount <= Some(50)) || *discount == None),
            BookItem::EBook(title, (_b, c)) => title != "" && *c > 0,
            BookItem::Collection(books) => !books.is_empty() && books.iter().all(|b| b.check_validity()),
            BookItem::OutOfPrint => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Procybit

a month ago

4.32ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } if *pages > 0 => match discount {
                Some(d) => 0 <= *d && *d <= 50,
                None => true,
            },
            BookItem::EBook(title, (_, f)) => !title.is_empty() && *f > 0,
            BookItem::Collection(c) => !c.is_empty() && c.iter().all(|b| b.check_validity()),
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

xxxxsk

a month ago

6.46ms

90.58kb

#[derive(Debug)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn clone(&self) -> Self {
        match self {
            BookItem::Book { pages, discount } => BookItem::Book {
                pages: *pages,
                discount: discount.clone(),
            },
            BookItem::EBook(title, tuple) => BookItem::EBook(title.clone(), *tuple),
            BookItem::Collection(items) => BookItem::Collection(items.iter().map(|item| item.clone()).collect()),
            BookItem::OutOfPrint => BookItem::OutOfPrint,
        }
    }
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                if let Some(discount) = discount {
                    (*discount <= 50) & (*pages >= 0) & (*discount >= 0)
                } else {
                    *pages >= 0
                }
            },
            BookItem::EBook(title, tuple) => {
                !title.is_empty() & (tuple.1 > 0)
            },
            BookItem::Collection(items) => {
                if items.is_empty() {
                    return false;
                }
                items.iter().all(|item| item.check_validity())
            },
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Evgenii Grigorenko

grevgeny

a month ago

4.38ms

90.58kb

pub const MIN_PAGES: i32 = 1;
pub const MAX_DISCOUNT: i32 = 50;
#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages, discount } => Self::is_valid_book(*pages, *discount),
            Self::EBook(title, fields) => Self::is_valid_ebook(title, fields),
            Self::Collection(items) => !items.is_empty() && items.iter().all(Self::check_validity),
            Self::OutOfPrint => false,
        }
    }
    fn is_valid_book(pages: i32, discount: Option<i32>) -> bool {
        pages >= MIN_PAGES && discount.map_or(true, |d| (0..=MAX_DISCOUNT).contains(&d))
    }
    fn is_valid_ebook(title: &str, version: &(i32, i32)) -> bool {
        !title.is_empty() && version.1 > 0
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

brucecox01

a month ago

4.32ms

90.58kb

#[derive(Debug,Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount} if *pages > 0 =>
                if let Some(discount) = discount {
                    *discount >= 0 && *discount <= 50
                } else {
                    true
                },
            BookItem::EBook(title, (_, b)) if title.len() > 0 && *b > 0 => true,
            BookItem::Collection(collection) if !collection.is_empty() =>
                collection.iter().all(|item| item.check_validity()),
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Krzysztof Atłasik

katlasik

2 months ago

4.87ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
   pub fn check_validity(&self) -> bool {
         match self {
             BookItem::Book { pages, discount} if *pages > 0 =>
                if let Some(d) = discount {
                    *d <= 50 && *d >= 0
                } else {
                    true
                },
              BookItem::EBook(title, (_, y)) if !title.is_empty() && *y > 0 => true,
              BookItem::Collection(items) => 
                  !items.is_empty() && items.iter().all(|item| item.check_validity()),
              BookItem::OutOfPrint => false,
             BookItem::Book { .. } => false,
             BookItem::EBook(_, _) => false
         }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Ushakov Andrey

stdstring

2 months ago

9.33ms

90.51kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages, discount: None } if *pages > 0 => true,
            Self::Book { pages, discount: Some(discount) } if (*pages > 0) && (*discount >= 0) && (*discount <= 50) => true,
            Self::EBook (title, (_, value1)) if !title.is_empty() && (*value1 > 0) => true,
            Self::Collection (items) if !items.is_empty() && items.iter().all(|item| item.check_validity()) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Tengz Mao

MaoX-Yu

2 months ago

3.89ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages, discount } if *pages > 0 && (discount.is_none() || discount.unwrap() >= 0 && discount.unwrap() <= 50) => true,
            Self::EBook(a, (_, c)) if !a.is_empty() && *c > 0 => true,
            Self::Collection(v) if !v.is_empty() && v.iter().all(|item| item.check_validity()) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Philippe Massicotte

PMassicotte

2 months ago

4.73ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    fn is_valid_book(pages: i32, discount: Option<i32>) -> bool {
        pages > 0 && discount.map_or(true, |d| (0..=50).contains(&d))
    }
    fn is_valid_ebook(msg: &String, b: &i32) -> bool {
        !msg.is_empty() && *b > 0
    }
    fn is_valid_collection(items: &[BookItem]) -> bool {
        !items.is_empty() && items.iter().all(|x| x.check_validity())
    }
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => Self::is_valid_book(*pages, *discount),
            BookItem::EBook(msg, (_, b)) => Self::is_valid_ebook(msg, b),
            BookItem::Collection(items) => Self::is_valid_collection(items),
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

0x0f1

Paul4673

2 months ago

6.37ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book {pages , discount } if *pages > 0 && (*discount == None || ( discount.unwrap() >=0 && discount.unwrap() <=50 )) => true,
            BookItem::EBook(msg, (_a, b)) if !msg.is_empty() && *b > 0  => true,
            BookItem::Collection(items) if !items.is_empty() && items.iter().all(|x| x.check_validity())=> true,
           _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

AnKarl

Zythophilus

2 months ago

4.31ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book{pages, discount} if *pages > 0 && (*discount == None || (discount.unwrap() >= 0 && discount.unwrap() <= 50) ) => true,
            BookItem::EBook(title, (first, second)) if !title.is_empty() && *second > 0 => true,
            BookItem::Collection(vec) if !vec.is_empty() => {
                for item in vec {
                    if !item.check_validity() {
                        return false
                    }
                }
                true
            },
            _ => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

vanos001

2 months ago

4.93ms

90.58kb

#[derive(Debug,Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        return match self {
            Self::Book{pages : p, discount : None} if *p > 0 => true,
            Self::Book{pages : p, discount : Some(_d @ 0..=50 )} if *p > 0 => true,
            Self::EBook(n,(_,r)) if !n.is_empty() && *r > 0 => true,
            Self::Collection(t) if !t.is_empty() && t.iter().all(|e| e.check_validity()) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

vanos001

2 months ago

4.53ms

90.58kb

#[derive(Debug,Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        return match self {
            Self::Book{pages : p, discount : None} if *p > 0 => true,
            Self::Book{pages : p, discount : Some(d)} if *p > 0 && *d >=0 && *d <= 50 => true,
            Self::EBook(n,(_,r)) if !n.is_empty() && *r > 0 => true,
            Self::Collection(t) if !t.is_empty() && t.iter().all(|e| e.check_validity()) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Herman effendi

hrmneffdii

2 months ago

4.53ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book{pages, discount} => {
                *pages > 0 && discount.map_or(true, |d| d >= 0 && d <= 50)
            },
            BookItem::EBook(title, (_, second)) => !title.is_empty() && *second > 0,
            BookItem::Collection(items) =>
                !items.is_empty() && items.iter().all(|item| item.check_validity()),
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

alexsavio

2 months ago

4.35ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book{pages, discount} => {
                *pages > 0 && discount.map_or(true, |d| d >= 0 && d <= 50)
            },
            BookItem::EBook(title, (_, second)) => !title.is_empty() && *second > 0,
            BookItem::Collection(items) =>
                !items.is_empty() && items.iter().all(|item| item.check_validity()),
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

ikatlinsky

2 months ago

5.05ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book {pages, discount} => {
                return *pages >= 0 && discount.map_or(true, |d| d >= 0 && d <= 50);
            },
            BookItem::EBook(title, (l, r)) => !title.is_empty() && *r > 0,
            BookItem::Collection(items) => items.len() > 0 && items.iter().all(|i| i.check_validity()),
            BookItem::OutOfPrint => false,
            _ => panic!("unknown book item"),
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

diucicd

2 months ago

4.43ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                *pages > 0 && discount.map_or(true, |d| d <= 50 && d >= 0)
            }
            BookItem::EBook(title, tuple) => !title.is_empty() && tuple.0 > 0 && tuple.1 > 0,
            BookItem::Collection(items) => {
                items.len() > 0 && items.iter().all(|item| item.check_validity())
            }
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

LW44

whovian44

2 months ago

4.34ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages: 1.., discount: Some(0..=50) | None } |
            Self::EBook(_, (_, 1..)) | 
            Self::Collection(_) 
            if self.non_pattern_validity_check() => true,
            Self::OutOfPrint |
            _ 
            => false
        }
    }
    /// internal function used for if-guards
    fn non_pattern_validity_check(&self) -> bool {
        // fricken expressions not being pattern-able lol
        match self {
            Self::EBook(string, (_, _)) => !string.is_empty(),
            Self::Collection(vec) => {
                if vec.is_empty() {
                    return false
                }
                vec.iter().all(Self::check_validity)
            },
            Self::Book {..} | Self::OutOfPrint => true
        }
    } 
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Sergey Matyash

matiaspub

2 months ago

4.92ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book{pages: 1.., discount: None | Some(0..=50)} => true,
            Self::EBook(title, (_, 1..)) if !title.is_empty() => true,
            Self::Collection(items) if !items.is_empty() && items.iter().all(|book| book.check_validity()) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Prafful

iamsahu

2 months ago

4.96ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match &self {
           BookItem::Book{pages,discount} => {
                if *pages < 1 {
                    return false
                }
                match discount {
                    None => return true,
                    _ => {
                        if discount.unwrap() > 50 || discount.unwrap() < 0 {
                            return false
                        }
                    }
                }
                
                return true
            },
            BookItem::EBook(n, (_x, y)) => {
                if n.len() == 0 {
                    return false
                }
                if *y < 1 {
                    return false
                }
                return true
            },
            BookItem::Collection(n) => {
                if n.len() == 0 {
                    return false
                }
                for item in n {
                    if !item.check_validity() {
                        return false
                    }
                }
                return true
            },
            BookItem::OutOfPrint => {
                false
            }
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Nicolai

Posmac

2 months ago

4.72ms

90.58kb


#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    
    pub fn check_validity(&self) -> bool{
        match self {
            BookItem::Book { pages, discount } => {
                if *pages <= 0 {
                    return false;
                }
                match discount {
                    Some(d) => {
                        if *d < 0 || *d > 50  {
                            return false;
                        } 
                        return true;
                    },
                    None => return true,
                }
            },
            BookItem::EBook(title, tuple) => {
                if title.is_empty() {
                    return false;
                }
                if tuple.1 <= 0 {
                    return false;
                }
                return true;
            },
            BookItem::Collection(book_items) => {
                if book_items.is_empty() {
                    return false;
                }
                for book in book_items.iter() {
                    if !book.check_validity() {
                        return false;
                    }
                }
                return true;
            },
            BookItem::OutOfPrint => return false,
        }
    }
    // TODO: Finish the implementation
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

LeonardoPinheiro23

2 months ago

5.06ms

90.58kb


#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount: None } => *pages > 0,
            BookItem::Book { pages, discount: Some(discount) } => {
                *pages > 0 && *discount >= 0 && *discount <= 50
            }
            BookItem::EBook(string, (_, second_field)) => !string.is_empty() && *second_field > 0,
            BookItem::Collection(book_items) => {
                !book_items.is_empty() &&
                book_items.iter().all(|book_item| book_item.check_validity())
            },
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

sjmellor

3 months ago

5.56ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
             Self::Book { pages: 1.., discount: None | Some(0..=50) } => true,
             Self::EBook(title, (_, 1..)) if !title.is_empty() => true,
             Self::Collection(i) if !i.is_empty() && i.iter().all(|x| x.check_validity()) => true,
             _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Tommytto

3 months ago

5.47ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages: 1.., discount: None | Some(0..=50) } => true,
            // BookItem::Book { pages, discount } => {
            //     if *pages <= 0 {
            //         return false;
            //     }
            //     if let Some(discount) = discount {
            //         return *discount >= 0 && *discount <= 50;
            //     }
            //     return true
            // },
            BookItem::EBook(title, (_, b)) => title.len() > 0 && *b > 0,
            BookItem::Collection(books) => books.len() > 0 && books.iter().all(|book| book.check_validity()),
            BookItem::OutOfPrint => false,
            _ => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Tommytto

3 months ago

5.44ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                if *pages <= 0 {
                    return false;
                }
                if let Some(discount) = discount {
                    return *discount >= 0 && *discount <= 50;
                }
                return true
            },
            BookItem::EBook(title, (_, b)) => title.len() > 0 && *b > 0,
            BookItem::Collection(books) => books.len() > 0 && books.iter().all(|book| book.check_validity()),
            BookItem::OutOfPrint => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

ggnne

3 months ago

4.79ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages: 1.., discount: None | Some(0..=50) } => true,
            BookItem::EBook(title, (_, 1..)) if !title.is_empty() => true,
            BookItem::Collection(vec) if !vec.is_empty() && vec.iter().all(BookItem::check_validity) => true,
            _ => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

ggnne

3 months ago

5.41ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => {
                if let Some(d) = discount {
                    return (*d >= 0) && (*d <= 50) && (*pages > 0);
                } else {
                    return *pages > 0
                }
            }
            BookItem::EBook(title, (_, i)) => {
                !title.is_empty() && (*i > 0)
            }
            BookItem::Collection(vec) => {
                !vec.is_empty() && vec.iter().map(|bi| bi.check_validity()).all(|x| x)
            }
            BookItem::OutOfPrint => false
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Elizabeth Doughty

Thymelizabeth

3 months ago

4.98ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages: 1.., discount: None | Some(0..=50) } => true,
            Self::EBook(title, (_, 1..)) if !title.is_empty() => true,
            Self::Collection(c) if !c.is_empty() && c.iter().all(BookItem::check_validity) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Elizabeth Doughty

Thymelizabeth

3 months ago

5.31ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages, discount: None } if *pages > 0 => true,
            Self::Book { pages, discount: Some(d) } if *pages > 0 && (0..=50).contains(d) => true,
            Self::EBook(title, (_, i)) if !title.is_empty() && *i > 0 => true,
            Self::Collection(c) if !c.is_empty() && c.iter().all(BookItem::check_validity) => true,
            _ => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Viktor Merkurev

fennr

3 months ago

4.49ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            BookItem::Book { pages, discount } => *pages > 0 && discount.map_or(true, |d| d >= 0 && d <= 50),
            BookItem::EBook(title, (width, height)) => {
                !title.is_empty() && *width > 0 && *height > 0
            }
            BookItem::Collection(items) => {
                !items.is_empty() && items.iter().all(|item| item.check_validity())
            }
            BookItem::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

Nguyen Vo Hoang Son

sonmessia

3 months ago

5.78ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages, discount } => {
                if let Some(d) = discount {
                    *pages > 0 && *d >= 0 && *d <= 50
                } else {
                    *pages > 0
                }
            }
            Self::EBook(title, (width, height)) => {
                !title.is_empty() && *width > 0 && *height > 0
            }
            Self::Collection(items) => {
                if items.is_empty() {
                    false
                } else {
                    items.iter().all(|item| item.check_validity())
                }
            }
            Self::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}

shibu-t

4 months ago

5.02ms

90.58kb

#[derive(Debug, Clone)]
pub enum BookItem {
    Book { pages: i32, discount: Option<i32> },
    EBook(String, (i32, i32)),
    Collection(Vec<BookItem>),
    OutOfPrint,
}
impl BookItem {
    // TODO: Finish the implementation
    pub fn check_validity(&self) -> bool {
        match self {
            Self::Book { pages, discount } => {
                if let Some(d) = discount {
                    *pages > 0 && *d >= 0 && *d <= 50
                } else {
                    *pages > 0
                }
            }
            Self::EBook(title, (width, height)) => {
                !title.is_empty() && *width > 0 && *height > 0
            }
            Self::Collection(items) => {
                if items.is_empty() {
                    false
                } else {
                    items.iter().all(|item| item.check_validity())
                }
            }
            Self::OutOfPrint => false,
        }
    }
}
// Example usage
pub fn main() {
    let book_a = BookItem::Book {
        pages: 42,
        discount: Some(100),
    };
    let ebook_b = BookItem::EBook("hello".to_string(), (1, 2));
    let collection_c = BookItem::Collection(vec![book_a.clone(), BookItem::OutOfPrint]);
    assert!(
        !book_a.check_validity(),
        "Book with discount > 50 should be invalid"
    );
    assert!(
        ebook_b.check_validity(),
        "EBook with valid title and tuple should be valid"
    );
    assert!(
        !collection_c.check_validity(),
        "Collection containing invalid items should be invalid"
    );
    assert!(
        !BookItem::OutOfPrint.check_validity(),
        "OutOfPrint should always be invalid"
    );
}