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

vqk-2003

5 hours ago

214.04ms

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

ffrie

10 hours ago

197.81ms

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

reborn3d

a day ago

212.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(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 = |details| {
        return 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"
    );
}

Ramon Silva

rsilva1

3 days ago

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

Omar Saber Talaat Abdelrahman

omar-s-ta

5 days ago

231.81ms

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

SpontaneousOverthrow

8 days ago

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

makinpaper

9 days ago

213.27ms

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: f32, b: f32| -> f32 { 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 = |a: String| -> 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"
    );
}

<YoungAncient/>

youngancient

10 days ago

204.81ms

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

Dan Wayne

danwayne-me

11 days ago

203.72ms

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

kasaxpong

14 days ago

209.04ms

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

Asrul Firdaus

AsrulF

15 days ago

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

Kishan

wdcs-kishansudani

18 days ago

211.16ms

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 = |items| format!("Checkout complete: {items}");
    (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"
    );
}

Dharm Singh

dharmvr1

20 days ago

256.15ms

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

Mykhailo Huzhvii

Ymkavi

23 days ago

207.16ms

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
    };
    let checkout_cart = |cart_details: String| {
        String::from(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"
    );
}

银雀Sparrxw

Sparr0www820

a month ago

206.59ms

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

Yummy-Yums

a month ago

229.28ms

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

Vincent SAMY

vsamy

a month ago

216.75ms

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

Ari Karim

arikarim

a month ago

245.15ms

91.83kb

pub fn create_typed_closures() -> (
    impl Fn(f32, f32) -> f32,
    impl FnMut(&mut f32, f32) -> f32,
    impl FnOnce(String) -> String
) {
    // 2. Implement calculate_total closure here
    let calculate_total = |price, rate| { price + price * rate};
    // 3. Implement apply_discount closure here
    let apply_discount = |total: &mut f32, amount| {
         *total -= amount;
         total.clone()
        };
    // 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"
    );
}

Jai

jsat97

a month ago

214.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(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| {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"
    );
}

Abhishek Sharma

0xAbhiDev

a month ago

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

nojae15

a month ago

227.10ms

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

jfloresremar

a month ago

229.26ms

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 = |total: f64, tax_percentage: f64| total + (total * tax_percentage);
    // 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 =
        |message: String| -> String { message.replace("Items:", "Checkout complete:") };
    (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"
    );
}

QuJohan

2 months ago

230.85ms

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| { price + price*tax };
    // 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 = |instr: String| -> String {
        instr.replace("Items:", "Checkout complete:")
    };
    (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"
    );
}

ghoti225

2 months ago

212.70ms

91.69kb

// 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| -> f32 {
        price + tax_rate * price
    };
    // 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 = |instr: String| -> String {
        instr.replace("Items:", "Checkout complete:")
    };
    let original_string = "Hello World! This is a World of Rust.";
    let replaced_string = original_string.replace("World", "Rustacean");
    println!("Original: {}", original_string);
    println!("Replaced: {}", replaced_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"
    );
}

Gurneet singh

GS-Jatt

2 months ago

198.42ms

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

Omar

OmniKobra

2 months ago

201.24ms

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

jh4vision

2 months ago

240.59ms

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

jh4vision

2 months ago

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

msned

2 months ago

284.41ms

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,t| {
        return p + (p*t);
    };
    // 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"
    );
}

TheJanzap

2 months ago

222.81ms

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

muemart

2 months ago

208.60ms

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

Christophe Mohimont

mohic

2 months ago

221.02ms

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: &mut f32, discount| *total -= discount;
    let checkout_cart = |cart_details| format!("Checkout complete: {cart_details}");
    (calculate_total, apply_discount, checkout_cart)
}

shahab-tplus

2 months ago

197.04ms

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: f64, b: f64| a + a * b;
    // 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 = |s: String| format!("Checkout complete: {}", s).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"
    );
}

Smith, Taylor

a647965_fidelity

2 months ago

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

Chih Ying Yen

xavierforge

2 months 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

2 months 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

2 months 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

3 months 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

3 months 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

3 months 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

3 months 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

artemnistuley

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

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