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

Vincent SAMY

vsamy

a day 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

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

7 days 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

9 days 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

12 days 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

14 days 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

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

LS Koenig

ghoti225

17 days 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

18 days 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

20 days 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

24 days 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

24 days 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

25 days 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

2 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

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

Wouter

WouterMartens

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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