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

Chih Ying Yen

xavierforge

3 days ago

218.66ms

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 = |total: &mut f32, discount| *total -= discount; 
    // 4. Implement checkout_cart closure here
    let checkout_cart = |detail| {format!("Checkout complete: {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"
    );
}

StevenCanDrink

3 days ago

212.60ms

92.86kb

// 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 for<'a> Fn(&'a 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");
}

amdfxlucas

5 days ago

227.10ms

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 = |a: f64,b: f64| { 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 = move |x| { format!("Checkout complete: Items: {}", 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"
    );
}

Akira

itsmewayne

8 days ago

250.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 = |x,y| {
        x+x*y
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |x:&mut f64,y:f64| {
        *x-=y;
    };
    // 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"
    );
}

undefeated_

boyboi86

9 days ago

263.65ms

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

toto

12 days ago

227.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(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| price + price * tax;
    // 3. Implement apply_discount closure here
    let apply_discount = |price: &mut f64, discount: f64| *price -= discount;
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart: 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"
    );
}

aghia98

12 days ago

203.86ms

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 = |price: &mut f64, discount: f64| { *price -= discount; };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart: 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"
    );
}

Artem Nistuley

artemnistuley

12 days ago

208.21ms

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.mul_add(b, a)
    };
    // 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: 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"
    );
}

GunGraveCpp

12 days ago

214.99ms

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.mul_add(b, a)
    };
    // 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"
    );
}

GunGraveCpp

12 days ago

269.12ms

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.mul_add(b, a)
    };
    // 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"
    );
}

manu3618

14 days ago

209.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| { price + price * tax };
    // 3. Implement apply_discount closure here
    let apply_discount =|cart: &mut f64, discount| { *cart -= 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"
    );
}

Lvfalue

15 days ago

207.09ms

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

visanr

17 days ago

205.00ms

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| {
        *total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |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"
    );
}

Ranjith Thangavel

RanjithECE24

19 days ago

216.14ms

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 = |total: &mut f64, discount: f64| {
        *total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |carts: String| -> String {
        format!("Checkout complete: {carts}")
    };
    (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"
    );
}

Luka Bračun

lbracun

22 days ago

197.82ms

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 = |price: &mut f64 , 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"
    );
}

bzdula

23 days ago

214.74ms

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 = |sum: &mut f64, discount| {
        *sum -= 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"
    );
}

Wouter

WouterMartens

a month ago

236.65ms

91.83kb

pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32),
    impl FnOnce(String) -> String,
) {
    let calculate_total = |price, tax_rate| price + price * tax_rate;
    let apply_discount = |total_price: &mut f32, discount: f32| {
        *total_price -= discount
    };
    let checkout_cart = |cart_details| {
        format!("Checkout complete: Items: {cart_details}")
    };
    (calculate_total, apply_discount, checkout_cart)
}
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    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"
    );
}

Andy Randrianirina

andyslash

a month ago

208.93ms

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: &mut f64, discount: f64| *total -= discount ;
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |details: String| format!("Checkout complete: {details}").to_string();
    (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"
    );
}

AtlasVakyrie

a month ago

210.65ms

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 = |price: &mut f64, discount: f64| { *price -= discount};
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_string: String| {
        // "Checkout complete: Items: ".to_string() + cart.join(", ")
        String::from("Checkout complete: ".to_string() + &cart_string)
        };
    (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"
    );
}

m1031

monorail103

a month ago

205.73ms

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

Daniel Mestas

miel-codeai

a month ago

208.17ms

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 = |total_price: &mut f64, discount| *total_price -= discount;
    let checkout_cart = |cart| format!("Checkout done: {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"
    );
}

Daniel Mestas

miel-codeai

a month ago

224.20ms

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 = |total_price: &mut f64, discount| *total_price -= discount;
    let checkout_cart = |cart| format!("Checkout done: {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"
    );
}

Rocky.C

cloki0610

a month ago

232.67ms

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 = |price: &mut f64, discount: f64| {
        *price -= discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |cart: String| {
        format!("checkout done : {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"
    );
}

slaws

a month ago

207.96ms

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 =  |price: &mut f64, discount: f64| {
        *price -= discount
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |cart: String| {
        format!("checkout done : {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"
    );
}

Baron Curtin

baroncurtin2

a month ago

203.70ms

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 = |total_price: &mut f64, discount: f64| { *total_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"
    );
}

Evrins Hu

evrins

a month ago

235.56ms

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 = |total: &mut f64, discount: f64| {
        *total -= discount;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart =
        move |detail: String| -> String { format!("Checkout complete: {}", 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"
    );
}

Heino Mortensen

hmortensen83

a month ago

213.27ms

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| price + price * tax;
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, price| *total -= price;
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |value| format!("Checkout complete: {value}").to_string();
    (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"
    );
}

johndoe30bc

a month ago

262.06ms

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 = |cart_total: &mut f64, discount: f64| *cart_total -= discount;
    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"
    );
}

Cristian Prieto

cprieto

a month ago

209.90ms

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 = |total: &mut f64, discount: f64| *total = *total - 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"
    );
}

xxxxsk

a month ago

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

FredoPo

a month ago

213.66ms

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

Evgenii Grigorenko

grevgeny

a month ago

264.67ms

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 = |total_price: &mut f64, discount| {
        *total_price -= discount;
    };
    let checkout_cart = |cart_details| format!("Checkout complete: {cart_details}");
    (calculate_total, apply_discount, checkout_cart)
}
pub fn main() {
    let (calculate_total, mut apply_discount, checkout_cart) = create_typed_closures();
    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"
    );
}

bernardoLY19

a month ago

252.48ms

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

Miguel Ángel Allende

maallende

a month ago

204.67ms

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| {
        price + (price * tax)
    };
    // 3. Implement apply_discount closure here    
    let apply_discount = move |total: &mut f64, discount: f64| {
        *total -= discount;        
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |cart_details: String| {
        format!("Checkout complete: {}", cart_details)
    };
    // We need to wrap apply_discount to match the expected signature
    let apply_discount = move |total: &mut f64, discount: f64| apply_discount(total, discount);
    (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"
    );
}

Procybit

a month ago

210.01ms

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, disc| *total -= disc;
    // 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"
    );
}

brucecox01

2 months ago

210.32ms

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, taxrate| {price + price * taxrate};
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f64, discount| {*total -= discount};
    // 4. Implement checkout_cart closure here
    let checkout_cart = move |details| {format!("Checkout complete: Items: {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"
    );
}

Krzysztof Atłasik

katlasik

2 months ago

194.12ms

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 = | total_price: &mut f32, 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"
  );
}

coreyralph

2 months ago

210.21ms

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 = | total_price: &mut f32, 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"
    );
}

medzernik

2 months ago

246.25ms

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| {
      f32::floor(a * (1.+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 = move |a| {format!("Checkout complete: Items: {}",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"
    );
}

Philippe Massicotte

PMassicotte

2 months ago

232.54ms

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 = |price: &mut f64, discount: f64| *price -= discount;
    // 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"
    );
    // println!("{cart_details}");
}

Kr0wZ

2 months ago

197.80ms

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

Ushakov Andrey

stdstring

2 months ago

247.09ms

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: f64| { *total_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"
    );
}

Herman effendi

hrmneffdii

2 months ago

206.64ms

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

vanos001

2 months ago

210.02ms

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 = |p : f64,t : f64| -> f64 {
        return p + p*t;
    };
    // 3. Implement apply_discount closure here
    let apply_discount = |p : &mut f64,d : f64| {
        *p -= d;
    };
    // 4. Implement checkout_cart closure here
    let checkout_cart = |items : String| -> String {
        return 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"
    );
}

alexsavio

2 months ago

199.50ms

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| { *total -= 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"
    );
}

Tengz Mao

MaoX-Yu

2 months ago

217.81ms

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

0x0f1

Paul4673

2 months ago

221.44ms

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 = |total_price : &mut f32, amount| {
        *total_price -= amount;
    };
    // 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"
    );
}

Enes

enesscevik

2 months ago

225.79ms

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

Luigi Terrone

LuigiTer

2 months ago

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

whhc

2 months ago

206.95ms

91.83kb

pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32) -> (),
    impl FnOnce(String) -> String,
) {
    let calculate_total = |a, b| a + a * b;
    let apply_discount = |a: &mut f32, b: f32| *a -= b;
    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"
    );
}