Closure Types

Closures in Rust are categorized based on how they interact with the environment and the variables they capture. The three main types are Fn, FnMut, and FnOnce. Understanding and using these types effectively is key to mastering closures in Rust.

Closure Type Definitions

Fn: A closure that borrows its environment immutably. It is useful for read-only operations.
FnMut: A closure that mutably borrows its environment, allowing it to modify variables.
FnOnce: A closure that takes ownership of its captured variables, consuming them in the process.

Your Task

Implement the following closures and their respective behaviors:

calculate_total: An Fn closure that calculates the total price of an item, including tax (price + price * tax_rate).
apply_discount: An FnMut closure that mutates the cart total by subtracting a given discount.
checkout_cart: An FnOnce closure that consumes the cart's details (a String) and returns a confirmation message.

Hints

Click here to reveal hints

Use impl Fn, impl FnMut, or impl FnOnce to define the types of the closures. e.g.

  pub fn return_closure() -> impl Fn(f64, f64) -> f64 {
      //
  }

Editor not available on Mobile!

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

Solutions

ycgw

2 days ago

214.17ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f32, tax_rate: f32| -> f32 { price + price * tax_rate };
    // 3. Implement apply_discount closure here
    let apply_discount = |total_price: &mut f32, discount: f32| *total_price -= discount;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details: String| "Checkout complete: ".to_string() + &cart_details;
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Maintain

duonghb53

4 days ago

213.75ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| {
        a + a * b
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f32, b| {
        *a -= b
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| {
        format!("Check complete {}", a)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Prafful

iamsahu

5 days ago

203.92ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = | x, y | { x + x*y };
    // 3. Implement apply_discount closure here
    let apply_discount = | x: &mut f64, discount | { *x -= discount };
    // 4. Implement checkout_cart closure here
    let checkout_cart = | x | { format!("Checkout complete: {}", x) };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

ikatlinsky

5 days ago

242.06ms

92.22kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (impl Fn(f64, f64) -> f64, impl FnMut(&mut f64, f64) -> (), impl FnOnce(String) -> String) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f64, tax_rate: f64| -> f64 { price + price * tax_rate };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f64, discout: f64| { *price -= discout; };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details: String| {
        format!("Checkout complete: Items: {cart_details}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Seth Wood

seth-wood

7 days ago

227.03ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + (a * b);
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b: f64| {
        *a -= b;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| format!("Checkout complete: {}", a);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

diucicd

7 days ago

218.29ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a: f64, b: f64| a + a * b;
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b: f64| *a -= b;
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |s: String| format!("Checkout complete: {}", s);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Sergey Matyash

matiaspub

11 days ago

216.16ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f64, tax: f64| -> f64 {
        price + price * tax
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, discount: f64| {
        *total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart: String| -> String {
        format!("Checkout complete: {}", cart)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

LeonardoPinheiro23

17 days ago

211.22ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f64, tax_rate:f64| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |cost: &mut f64, discount: f64| {
       *cost -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details: String| {
        format!("Checkout complete: {}", cart_details)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Tommytto

21 days ago

210.91ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f32, tax_rate: f32| -> f32 {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |cart_total: &mut f32, discount: f32| {
        *cart_total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details: String| -> String {
        format!("Checkout complete: {details}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

sjmellor

24 days ago

234.83ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + (price * tax_rate)
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total_price: &mut f64, discount| {
        *total_price -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart| {
        format!("Checkout complete: {cart}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Nicolai

Posmac

a month ago

244.17ms

91.83kb


// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, discount: f64| {
        *total -=  discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart| {
        format!("Checkout complete: {cart}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

ggnne

a month ago

213.17ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, discount: f64| {
        *total -=  discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart| {
        format!("Checkout complete: {cart}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Elizabeth Doughty

Thymelizabeth

a month ago

205.18ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (impl Fn(f64, f64) -> f64, impl FnMut(&mut f64, f64), impl FnOnce(String) -> String) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| price + price * tax_rate ;
    // 3. Implement apply_discount closure here
    let apply_discount = |total_price: &mut f64, discount| { *total_price -= discount; };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details| format!("Checkout complete: {cart_details}");
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

arilet

a month ago

263.35ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String
)
{
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f32, tax_rate: f32| -> f32 {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total_price: &mut f32, discount: f32| {
        *total_price = *total_price - discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details: String| -> String {
        format!("{}{}", "Checkout complete: ", cart_details)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

roboquaternion

a month ago

243.37ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) 
{
    // 2. Implement calculate_total closure here
    let calculate_total= |price, tax| {price + price*tax};
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f64, discount| {*price -= discount};
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details| {format!("Checkout complete: {}", cart_details)};
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Nguyen Vo Hoang Son

sonmessia

a month ago

234.39ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,)
    {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| {
        a + a * b
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b| {
        *a -= b
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |s: String| format!("Checkout complete: {}", s);
    
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Splatrac

splatrac

a month ago

226.89ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
 ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| { return price + price * tax_rate };
    // 3. Implement apply_discount closure here
    let apply_discount = |total_price: &mut f64, discount| { *total_price -= discount; };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details| { format!("Checkout complete: Items: {}", cart_details) };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Health-Care-Movie

2 months ago

207.59ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + a * b;
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b| {*a -= b};
    // 4. Implement checkout_cart closure here
    let checkout_cart = |s: String| format!("Checkout complete: {}", s);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Trịnh Chấn Duy

Duyyy123

2 months ago

211.35ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + a * b;
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b| *a -= b;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a: String| format!("Checkout complete: {}", a);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Trịnh Chấn Duy

Duyyy123

2 months ago

297.52ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + a * b;
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b| *a -= b;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a: String| "Checkout complete".to_string() + a.as_str();
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Liyqq

2 months ago

217.74ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total_price: &mut f64, discount| {
        *total_price -= discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details: String| {
        let mut result = "Checkout complete: ".to_string();
        result.push_str(details.as_str());
        result
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Nathan GAUD

Natchica

2 months ago

199.85ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) ->  String, 
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |total: f32, pourcentage: f32| {
        total + total * pourcentage
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f32, pourcentage: f32| {
        *total = *total - pourcentage
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_detail: String| {
        format!("Checkout complete: {}", cart_detail)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

shibu-t

2 months ago

209.01ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f32, tax_rate: f32| {
        let total = price + price * tax_rate;
        total
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: & mut f32, discount_rate: f32| {
        *price = *price - discount_rate;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart: String| {
        let checkout_message = format!("Checkout complete: {}", cart);
        checkout_message
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

mishbah

2 months ago

262.70ms

91.28kb

pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + a * b;
    // 3. Implement apply_discount closure here
    let apply_discount = |t: &mut f32, d| *t -= d;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |t| format!("Checkout complete: {}", t);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Jason

Jason-fy-wang

2 months ago

219.54ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64)->f64, 
    impl FnMut(&mut f64, f64), 
    impl FnOnce(String)->String) {
    // 2. Implement calculate_total closure here
    let calculate_total = |p, t|->f64 { p+p*t};
    // 3. Implement apply_discount closure here
    let apply_discount = |p:&mut f64, c:f64| { *p=*p-c;};
    // 4. Implement checkout_cart closure here
    let checkout_cart = |itm| {format!("Checkout complete:{}", itm)};
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

VerweyFr

2 months ago

219.55ms

91.32kb


pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    let calculate_total = |price: f64, tax_rate: f64| -> f64 {
        price + price * tax_rate
    };
    let apply_discount = |total_price: &mut f64, discount: f64| {
        *total_price -= discount;
    };
    let checkout_cart = move |cart_details: String| -> String {
        format!("Checkout complete: {}", cart_details)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

vijayabhaskar badireddi

ptcte

2 months ago

202.46ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| price + price * tax_rate;
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount| *price -= discount;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |items| format!("Checkout complete: {}", items);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Assylbek Razakhbergenov

asylbek27

2 months ago

253.52ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32, 
    impl FnMut(&mut f32, f32), 
    impl FnOnce(String) -> String,
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount| {
        *price -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details| {
        format!("Checkout complete: {}", details)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Assylbek Razakhbergenov

asylbek27

2 months ago

276.57ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32, 
    impl FnMut(&mut f32, f32), 
    impl FnOnce(String) -> String,
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount: f32| {
        *price -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details| {
        format!("Checkout complete: {}", details)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Tboot

tboot-0510

2 months ago

277.33ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() ->(
    impl Fn(f32,f32) -> f32,
    impl FnMut(&mut f32,f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| {a + (a*b)};
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f32, b: f32| {
        *a -= b;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details: String| format!("Checkout complete: {details}");
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Suresh Kumar

toddlers

3 months ago

209.13ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() ->(
        impl Fn(f32,f32) -> f32,
    impl FnMut(&mut f32,f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a,b| a + (a*b);
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32,discount|{
        *price -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |d| {
        format!("Checkout complete: {}",d)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Jason

chenjie1219

3 months ago

211.14ms

91.52kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| price + price * tax_rate;
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount| {
        *price -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details: String| format!("Checkout complete: {details}");
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

lugtester

3 months ago

224.49ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32, 
    impl FnMut(&mut f32,f32), 
    impl FnOnce(String) -> String
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount| {
        *price -= discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |my_str: String| {
        let my_new_str = "Checkout complete: ".to_string();
        my_new_str + &my_str
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

lugtester

3 months ago

208.50ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32, 
    impl FnMut(&mut f32,f32), 
    impl FnOnce(String) -> String
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount| {
        *price -= discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |my_str: String| -> String {
        let my_new_str = "Checkout complete: ".to_string();
        my_new_str + &my_str
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

lugtester

3 months ago

219.97ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32, 
    impl FnMut(&mut f32,f32), 
    impl FnOnce(String) -> String
    ) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f32, discount| {
        *price -= discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |my_str: String| -> String {
        let my_new_str = "Checkout complete: ".to_string();
        my_new_str + &my_str
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Yixian Du

duyixian1234

3 months ago

218.70ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f64, tax: f64| -> f64 { price + (price * tax) };
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, discount: f64| {
        *total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart =
        |cart_details: String| -> String { format!("Checkout complete: {}", cart_details) };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Aurimas Kuniutis

auriku

3 months ago

233.18ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f64, tax: f64| -> f64 { price + (price * tax) };
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, discount: f64| {
        *total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart =
        |cart_details: String| -> String { format!("Checkout complete: {}", cart_details) };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

gsspdev

3 months ago

234.08ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| { a + a * b };
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b: f64| { *a -= b };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| { format!("Checkout complete: {}:", a)};
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Artem

tich31337

3 months ago

241.76ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| { a+a*b };
    // 3. Implement apply_discount closure here
    let apply_discount = | a: &mut f64, b: f64| { *a -= b; };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| {format!("Checkout complete: {}", a)};
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Anna Komarova

Vlasanya

3 months ago

273.47ms

91.32kb

pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String
) {
    let calculate_total = |price: f64, tax_rate: f64| -> f64 {
        price + price * tax_rate
    };
    let apply_discount = |total: &mut f64, discount: f64| {
        *total -= discount;
    };
    let checkout_cart = |details: String| -> String {
        format!("Checkout complete: {}", details)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Paulo Lins

pblins

3 months ago

225.12ms

91.28kb

pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| price + price * tax_rate;
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f32, discount| *total = *total - discount;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |details| format!("Checkout complete: {}", details);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Denis SOURON

Brack0

3 months ago

209.47ms

91.83kb

pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    let calculate_total = |price: f64, tax_rate: f64| price + price * tax_rate;
    let apply_discount = |price: &mut f64, discount: f64| {
        *price -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_detais: String| format!("Checkout complete: {cart_detais}");
    (calculate_total, apply_discount, checkout_cart)
}

Icarus

IcarusxB

3 months ago

224.34ms

91.83kb

pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    let apply_discount = |price: &mut f64, discount| {
        *price -= discount;
    };
    let checkout_cart = |cart| {
        format!("Valid -> {}", cart)
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

AnKarl

Zythophilus

3 months ago

209.29ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| {
        a + (a * b)
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f32, b| {
        *a -= b;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| {
        format!("Checkout complete: {a}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Hung Dinh

nhdinh

3 months ago

215.58ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl Fn(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + a*b;
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b| {
        *a = *a - b;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a: String| format!("Checkout complete: {}", a);
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, apply_discount, checkout_cart) =
        create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Matthew Li

circles-png

3 months ago

229.23ms

91.83kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl Fn(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| {a + a * b};
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f32, b| {*a -= b};
    // 4. Implement checkout_cart closure here
    let checkout_cart = |s| format!("Checkout complete: {s}");
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Zeiion

4 months ago

209.38ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
)  {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, tax_rate| {
        price + price * tax_rate
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut _, discount| {
        *price = *price - discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |s| {
        format!("Checkout complete: {s}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Viktor Merkurev

fennr

4 months ago

215.91ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> 
    (
        impl Fn(f32, f32) -> f32,
        impl FnMut(&mut f32, f32),
        impl FnOnce(String) -> String,
    )
    {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| {
        a + a * b
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut _, b| {
        *a = *a - b;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| {
        format!("Checkout complete: {a}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Guilherme Cesário Strachan

strachan

4 months ago

216.35ms

91.32kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String,
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |a, b| a + a * b;
    // 3. Implement apply_discount closure here
    let apply_discount = |a: &mut f64, b| {
        *a -= b;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |a| format!("Checkout complete: {a}");
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}

Kentaro Abe

abekem

4 months ago

247.17ms

91.28kb

// 1. Based on the `main` function below,
// Find out the types of the closures and define them
pub fn create_typed_closures() -> (
    impl Fn(f64, f64) -> f64,
    impl FnMut(&mut f64, f64),
    impl FnOnce(String) -> String)
{
    // 2. Implement calculate_total closure here
    let calculate_total = |price: f64, tax_rate: f64| { return price + price * tax_rate };
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f64, discount: f64| { 
        *price = *price - discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |items: String| { format!("Checkout complete: {}", items) };
    (calculate_total, apply_discount, checkout_cart)
}
// Example usage
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    // Example tests
    assert_eq!(calculate_total(100.0, 0.2), 120.0);
    let mut total_price = 120.0;
    apply_discount(&mut total_price, 20.0);
    assert_eq!(total_price, 100.0);
    let cart_details = String::from("Items: Apple, Banana, Orange");
    assert_eq!(
        checkout_cart(cart_details),
        "Checkout complete: Items: Apple, Banana, Orange"
    );
}