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.

Understanding Closures

A closure is defined using a pair of vertical bars | that enclose the parameters, followed by the closure body. Here's a simple example of a closure that adds two numbers:

let add = |a: i32, b: i32| a + b;

In this example, add is a closure that takes two parameters, a and b, and returns their sum. You can call this closure just like a function:

let result = add(2, 3); // result is 5

Closures can capture variables from their enclosing scope. For example:

let x = 2;
let add_x = |a: i32| a + x;
let result = add_x(3); // result is 5

In this case, the closure add_x captures the variable x from the surrounding scope and adds it to its parameter a.

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.

Example

assert_eq!(add_closure(3, 4), 7);
assert_eq!(subtract_closure(10, 4), 6);
assert_eq!(multiply_closure(3, 5), 15);

Hints

Remember to use the let keyword to define closures.
Use the |a, b| syntax to define the parameters of the closure.

Editor not available on Mobile!

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

Solutions

Stefan Roas

sroas

an hour ago

3.58ms

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

Felipe Balbi

felipebalbi

4 hours ago

4.52ms

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

KuTaKe

kuttakke

a day ago

3.25ms

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
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a: i32, b: i32| a - b ;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

Yossa Bourne

terminox

a day ago

3.37ms

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

qiyuan711

a day ago

3.55ms

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

apst

2 days ago

12.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: i32, b: i32| {
        a + b
    };
    let subtract_closure = |a: i32, b: i32| {
        a - b
    };
    let multiply_closure = |a: i32, b: i32| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Jan Willems

2 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| {
        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)
}

Nicky Thorne

nickythorne

2 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| {
        // 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)
}

chuyuanlinzi

2 days ago

3.21ms

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
        a + b
    };
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a: i32, b: i32| {
        // Step 2: Implement here
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| {
        // Step 3: Implement here
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

xiuchiliudu

2 days ago

3.34ms

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

Philip Mercer

DV-13

2 days ago

5.14ms

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

yoakemae

2 days ago

3.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| {
        // 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| {
        return a - b;
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| {
        return a * b;
    };
    (add_closure, subtract_closure, multiply_closure)
}

tinthid

2 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| {
        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)
}

martin-unit

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

martin-unit

2 days ago

2.98ms

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

Neil Rayu

Neil-Rayu

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

RonaldoArayadev

2 days 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, 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)
}

Reda Bouaida

3ok

3 days ago

3.23ms

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: i32, b: i32| {
        a - b
    };
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Elizabeth Doughty

Thymelizabeth

3 days ago

2.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| {
        // 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)
}

Hudson

dalprahcd

3 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| a + b;
    let subtract_closure = |a, b| a - b;
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

devarajang

4 days ago

2.74ms

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
        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
        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
        a * b
    };
    (add_closure, subtract_closure, multiply_closure)
}

Jan

jeypiti

4 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: i32, b: i32| a+b;
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a: i32, b: i32| a-b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32| a*b;
    (add_closure, subtract_closure, multiply_closure)
}

Ushakov Andrey

stdstring

4 days ago

7.60ms

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

s.konishi

konishu

4 days 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| {
        // 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)
}

nichideropa

4 days ago

3.52ms

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

Pascal Dietrich

Cameo007

4 days ago

2.71ms

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

aleksey-vareto

4 days ago

3.02ms

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

akshayabhattarai

4 days ago

3.64ms

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

madeinheaven91

5 days ago

2.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| {
        // 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)
}

oDqnger

5 days ago

3.08ms

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:i32, b:i32|a-b;
    let multiply_closure = |a:i32, b:i32|a*b;
    (add_closure, subtract_closure, multiply_closure)
}

Takuro Niitsuma

otakumesi

5 days ago

2.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, 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)
}

Kohei Matsubara

matsuby

5 days ago

3.23ms

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

matsuyama-k1

5 days ago

3.28ms

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

kada-s

sy34

5 days 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| {
        // 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)
}

Ankeet Parikh

ankeetparikh

5 days ago

4.78ms

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

0xsmarter

5 days 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 : i32, b: i32| a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a : i32 , b : i32| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

aidan1magee

5 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| {
        // 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)
}

aidan1magee

5 days 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, 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)
}

maxvi

6 days ago

3.60ms

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

Hacker Major Sreekumar

hackermajorsreekumar

6 days ago

5.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| {
        // 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| {
        a - b
     };
    
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = | a : i32,b : i32 | {
        a * b
    };
    (add_closure, subtract_closure, multiply_closure) 
}

Rayen Benbetaieb

P0TER19

6 days ago

3.13ms

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

Ugochukwu Paul

ugochukwudev

6 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)
}

Rafael Lucas

rafaellucasprogm

7 days ago

3.28ms

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

Walquer Xavier Valles Ruiz

WalquerX

7 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| {
        // 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)
}

koslowskio

7 days ago

3.00ms

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 {
        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)
}

Rocky.C

cloki0610

7 days ago

3.31ms

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

Denis SOURON

Brack0

7 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| a + b;
    let subtract_closure = |a, b| a - b;
    let multiply_closure = |a, b| a * b;
    (add_closure, subtract_closure, multiply_closure)
}

Samori Gorse

shinuza

7 days ago

6.18ms

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
    };
    let multiply_closure = |a, b| {
        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)
}

tsuchiya-d

tsucchinoko

7 days ago

2.98ms

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

risemacro

7 days ago

3.74ms

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
        a + b;
    // Step 2:
    // Create the `subtract_closure` closure that subtracts two `i32` values.
    let subtract_closure = |a: i32, b: i32|
        a - b;
    // Step 3:
    // Create the `multiply_closure` closure that multiplies two `i32` values.
    let multiply_closure = |a: i32, b: i32|
        a * b;
    (add_closure, subtract_closure, multiply_closure)
}