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

Burak Doğaroğlu

hbdo

5 minutes ago

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

Infamous-711

infamous-711

an hour ago

2.19ms

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

今何求

jhq223

5 hours ago

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

Thatphum

ThatphumCpre

5 hours ago

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

Francisco

francisco-cmyk

6 hours ago

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

Will Barnett

xbarnett

6 hours ago

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

Masber

9 hours ago

2.05ms

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

Carlos Arias

carlos-quantexai

11 hours ago

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

mk-comm

15 hours ago

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

Adam Baker

nordicmachine

16 hours ago

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

majesticalcreature

17 hours ago

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

Joe Schneider

josschne

19 hours ago

2.40ms

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

sander-b-postnl

20 hours ago

2.14ms

81.28kb

pub fn create_closures() -> (
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
    impl Fn(i32, i32) -> i32,
) {
    // let the compiler determine the types of a and b.
    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)
}

Matei Stefanescu

matei

20 hours ago

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

Hendrik De Vloed

hendrikdevloed

a day ago

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

Kevin Wolny

rot11

a day ago

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

amassare

a day ago

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

Edoardo A. Morosanu

edoardo-morosanu

a day ago

2.26ms

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

Zava

zavakid

a day ago

2.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| {
        a + b
        // Step 1: Implement here
    };
    // 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)
}

viktr

victorchukwuemeka

a day ago

2.42ms

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

viktr

victorchukwuemeka

a day ago

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

Johnchoi913

a day ago

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

Moses

MosesMp3

a day ago

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

Parallaxes

a day ago

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

Elliott Smith

brum-b0

a day ago

2.06ms

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

Tiago Silva

tiagombsilva

2 days ago

2.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
        return a + b;
    };
     let subtract_closure = |a, b| {
        // Step 1: Implement here
        return a - b;
    };
     let multiply_closure = |a, b| {
        // Step 1: Implement here
        return 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)
}

i5.650

i5-650

2 days ago

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

retinotopic

2 days ago

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

Harry Hornbacher

hhornbacher

2 days ago

2.26ms

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

ogaca42

2 days ago

2.61ms

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

Ustin

2 days ago

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

Patrik Bjärterot

pbjarterot

2 days ago

2.27ms

85.88kb

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

Stefano Cianciulli

CianciuStyles

2 days ago

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

Jonathan Lopez

otherJL0

2 days ago

2.42ms

81.28kb

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

st01011

2 days ago

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

Ayush Rawat

ayushrawat10

2 days ago

2.29ms

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

Araden14

2 days ago

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

Marco Schanz

fuuman

2 days ago

2.45ms

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

Smit Barve

l3vith

2 days ago

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

damascussteel21

2 days ago

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

Egor Konovalov

agegorin

2 days ago

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

daanbouwman19

2 days ago

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

Oleksandr Romanov

alexromanov

2 days ago

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

Laurențiu STOLERIU

LaurentiuStoleriu

2 days ago

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

Hannes Küttner

hanneskuettner

2 days ago

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

Timepatterns

2 days ago

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

CountJung

2 days ago

2.19ms

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

Shubham Raizada

shbhmrzd

2 days ago

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

dev-puzzler

2 days ago

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

Ojash Neopane

oneopane

3 days ago

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