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

CB-42458

3 hours ago

2.17ms

81.30kb

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

Photon

quantumxt

2 days ago

2.32ms

81.30kb

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

omer-io

2 days ago

2.24ms

81.30kb

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

Derek

D-Rekk

7 days ago

2.32ms

81.30kb

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

Spivur

12 days ago

2.54ms

81.30kb

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

Marcin Jakuszko

marcinjakuszko

16 days ago

2.40ms

81.30kb

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

Marek Markiewka

marekzan

20 days ago

3.17ms

81.30kb

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

Umair Ziyan

umairziyan

21 days ago

2.44ms

81.30kb

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

Robert

relia1

21 days ago

2.45ms

81.30kb

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

Gideon Bature

GideonBature

21 days ago

2.67ms

81.30kb

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

hooneun

22 days ago

2.43ms

81.30kb

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

herlock77

22 days ago

2.61ms

81.30kb

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

nodbew

23 days ago

2.37ms

81.30kb

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

Alienora

25 days ago

2.45ms

81.30kb

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

Andrey Doroschenko

dorosch

a month ago

3.49ms

81.30kb

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

Jeremy Minton

JJMinton

a month ago

2.82ms

81.30kb

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

Jaisurya

JaiSuryaPrabu

2 months ago

3.14ms

81.30kb

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

Mrigesh patni

Mrigesh901

2 months ago

2.31ms

81.30kb

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

Rudolf Shenfeld

nerudxlf

3 months ago

2.17ms

81.30kb

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

dcodes

3 months ago

2.46ms

81.30kb

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

Ozen

enzo-rma

3 months ago

2.47ms

81.30kb

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