Closures

Closures in Rust are anonymous functions that can capture variables from their environment. They are similar to functions but have some unique properties that make them powerful and flexible. Closures are often used for short, simple operations and can be defined in a very concise way.

Your Task

Your task is to complete the implementation of the following closures:

add_closure: This closure should return the sum of two integers.
subtract_closure: This closure should return the difference between two integers.
multiply_closure: This closure should return the product of two integers.

Requirements

Each closure should take two parameters of type i32.
Each closure should return a result of type i32.

Hints

Here are some hints to help you solve the exercise:

Click here to reveal hints

Use the |a, b| syntax to define the parameters of the closure.
Since the type is already specified, it can be inferred, so you don't need to specify a and b.

Editor not available on Mobile!

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

Solutions

Kyle Diaz

kylediaz

4 hours ago

4.11ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| a+b;
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a,b| a-b;
    let multiply_closure = |a,b| a*b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Nikita Smirnov

Nismirno

18 hours ago

3.15ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| a + b;
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

iamforgettable

a day ago

3.27ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
        
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Kenneth Love

kennethlove

2 days ago

2.73ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Christopher Nielson

c-nielson

4 days ago

2.66ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

kosay

sarub0b0

7 days ago

2.81ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| a + b;
    let subtract_closure = |a, b| a - b;
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Elliott Draper

ejdraper

9 days ago

3.35ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Oebelus

oebelus

9 days ago

2.86ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Jonathan Voss

jvoss

12 days ago

2.68ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

エヴァンゲリオン

Lu-zihang

12 days ago

3.10ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {a * b};
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

dawwestk

15 days ago

3.48ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

PangoSea

kapaseker

17 days ago

3.09ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
        
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}
// Example usage
pub fn main() {
    let (add, subtract, multiply) = create_closures();
    // Example tests
    assert_eq!(add(3, 4), 7); // Expected: 7
    assert_eq!(subtract(10, 4), 6); // Expected: 6
    assert_eq!(multiply(3, 5), 15); // Expected: 15
}

Tboot

tboot-0510

19 days ago

2.70ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Sakura

sakkura

20 days ago

3.17ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        return a + b;
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

hemulya

21 days ago

3.83ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    let subtract_closure = |a, b| {
        a - b
    };
    
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

AminWhat

aminwhat

21 days ago

2.99ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        return a+b;
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure=|a,b|{
        return a-b;
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure=|a,b|{
return a*b;
    };
    (add_closure, subtract_closure, multiply_closure)
}

Dominicm99

21 days ago

3.33ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Isaac

ZAC-afkhub

21 days ago

2.93ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        return a + b
    };
    let subtract_closure = |a, b| {
        return a - b 
    };
    let multiply_closure = |a, b| {
        return a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Ahmet Özcan

ahmetoozcan

21 days ago

2.92ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a+b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a-b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a*b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Bugra Okumus

bgraokmush

22 days ago

3.20ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a+b
    };
    let subtract_closure = |a, b|{
        a-b
    };
    
    let multiply_closure = |a, b| {
        a*b
    };    
    (add_closure, subtract_closure, multiply_closure)
}

John Mayes

JohnMayes

22 days ago

3.77ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a: i32, b: i32| a + b;
    let subtract_closure = |a: i32, b: i32| a - b;
    let multiply_closure = |foo: i32, bar: i32| foo * bar;
    (add_closure, subtract_closure, multiply_closure)
}

Tristan

k86td

23 days ago

3.57ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Mikhail Shutov

mshutov

23 days ago

2.68ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

PavelPerna

24 days ago

3.57ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Pathan Khaleedh Khan

KhaleedhKhan

24 days ago

3.11ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a+b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a,b|{
        a-b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a,b| {
        a*b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Tplive

tplive

24 days ago

2.75ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    
    (add_closure, subtract_closure, multiply_closure)
}

Tom Cline

tom-cline

24 days ago

3.76ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

vikingNR

25 days ago

5.72ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a:i32, b:i32| -> i32{
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Stan

i2z4

25 days ago

3.62ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    let subtract_closure = |a, b| {
        a - b
    };
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

rawar089

25 days ago

3.16ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = | a, b| {
        a - b
    }; 
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = | a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Coronagraphist

a month ago

4.15ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
  
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
  
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Ruslan Frolov

DD7-13

a month ago

3.79ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    let subtract_closure = |a, b| {
        a - b
    };
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Vlad

mvldmihai

a month ago

2.91ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Tengz Mao

MaoX-Yu

a month ago

6.56ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
         a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

Tengz Mao

MaoX-Yu

a month ago

2.66ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a: i32, b: i32| -> i32 {
        // Step 1: Implement here
         a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a: i32, b: i32| -> i32 { a - b };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| -> i32 { a * b };
    (add_closure, subtract_closure, multiply_closure)
}

KuZo1304

a month ago

2.84ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Mohamed Elkebir

elkebirmed

a month ago

2.96ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| a+b;
    let subtract_closure = |a, b| a-b;
    let multiply_closure = |a, b| a*b;
    (add_closure, subtract_closure, multiply_closure)
}

Dhananjay Pandit

djpandit007

a month ago

3.70ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

elvert19

a month ago

3.07ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a+b
    };
    let subtract_closure = |a, b| {
        a-b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
let multiply_closure = |a, b| {
    a*b
};
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    (add_closure, subtract_closure, multiply_closure)
}

thirokata

a month ago

3.51ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Hans Melo

hansmelo

a month ago

2.87ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        return a + b;
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

Hans Melo

hansmelo

a month ago

3.39ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        return a + b;
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

shibu-t

a month ago

3.12ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a: i32, b: i32| {
        // Step 1: Implement here
        return a + b;
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a: i32, b: i32| {
        // Step 1: Implement here
        return a - b;
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| {
        // Step 1: Implement here
        return a * b;
    };
    (add_closure, subtract_closure, multiply_closure)
}

greggypf

a month ago

3.43ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

Sandeep chauhan

ryzen-xp

a month ago

2.69ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
       a+b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a ,b| {
        a-b 
    };
    let multiply_closure = |a , b| {
        a*b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    (add_closure, subtract_closure, multiply_closure)
}

Sandeep chauhan

ryzen-xp

a month ago

3.54ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
       a+b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a ,b| {
        a-b 
    };
    let multiply_closure = |a , b| {
        a*b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    (add_closure, subtract_closure, multiply_closure)
}

goerfra

a month ago

2.83ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a:i32, b:i32| a + b;
    let subtract_closure = |a:i32, b:i32| a - b;
    let multiply_closure = |a:i32, b:i32| a * b;
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    (add_closure, subtract_closure, multiply_closure)
}

ZlayerHunter

a month ago

2.82ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        // Step 1: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        // Step 1: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Oleg Durandin

OlegDurandin

a month ago

2.97ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a: i32, b: i32| {
        a+b
    };
    // Step 2:
    let subtract_closure = |a: i32, b:i32| a - b;
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    // Step 3:
    let multiply_closure = |a: i32, b: i32| a * b;
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    (add_closure, subtract_closure, multiply_closure)
}

Lephix

lephix

a month ago

2.87ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    let add_closure = |a, b| {
        // Step 1: Implement here
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a, b| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a, b| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}