Functions

Functions are a fundamental building block in Rust, as in any programming language. They allow you to encapsulate logic and reuse code, making your programs more modular and easier to understand. In this challenge, you will define and implement a series of simple functions that perform basic operations.

Your task

Your task is to define three functions:

add(a: i32, b: i32) -> i32 - This function should return the sum of a and b.
subtract(a: i32, b: i32) -> i32 - This function should return the difference between a and b.
multiply(a: i32, b: i32) -> i32 - This function should return the product of a and b.

You need to complete these functions so that they correctly perform the specified operations.

Example

let result = add(2, 3);
assert_eq!(result, 5);
 
let result = subtract(5, 3);
assert_eq!(result, 2);
 
let result = multiply(2, 3);
assert_eq!(result, 6);

Hints

You can define a function in Rust using the fn keyword followed by the function name, parameters in parentheses, and the return type.
Use the return keyword or just the last expression in the function body to return a value.
Make sure you use the pub keyword to make your functions public so they can be accessed from other modules.
Make sure your function signatures match the required signatures exactly.

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

13 minutes ago

2.19ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32, b:i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32, b:i32) -> i32 {
    a * b
}

Infamous-711

infamous-711

an hour ago

2.45ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

今何求

jhq223

5 hours ago

2.22ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32{
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32{
    a*b
}

Francisco

francisco-cmyk

6 hours ago

2.15ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    return a + b
}
pub fn subtract(a:i32, b:i32) -> i32 {
    return a - b
}
pub fn multiply(a: i32, b:i32) -> i32 {
    return a * b
}

Will Barnett

xbarnett

6 hours ago

2.03ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

JD

arukanoido

6 hours ago

2.21ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

oTTeuM

oTTeuMsTudio

6 hours ago

2.27ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b:i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Masber

9 hours ago

2.08ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32, b:i32) -> i32 {
    a * b
}

Carlos Arias

carlos-quantexai

11 hours ago

2.14ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32, b:i32) -> i32{
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32, b:i32) -> i32{
    a * b
}

Mikhail

mk-comm

15 hours ago

2.25ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Adam Baker

nordicmachine

16 hours ago

2.13ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    return a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    return a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    return a * b
}

majesticalcreature

17 hours ago

2.21ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Joe Schneider

josschne

19 hours ago

2.19ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

sander-b-postnl

20 hours ago

2.06ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Matei Stefanescu

matei

20 hours ago

2.23ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b:i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Hendrik De Vloed

hendrikdevloed

a day ago

2.22ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {a-b}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {a*b}

Kevin Wolny

rot11

a day ago

2.04ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a+b
}
pub fn subtract(a: i32, b:i32) -> i32 {
    a-b
}
pub fn multiply(a:i32, b:i32) -> i32 {
    a*b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

amassare

a day ago

2.37ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32,b:i32)->i32{
    a-b
}
pub fn multiply(a:i32,b:i32)->i32{
    a*b
}

Zava

zavakid

a day ago

2.28ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

viktr

victorchukwuemeka

a day ago

2.29ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32)-> i32{
    a - b
}
pub fn multiply(a: i32, b: i32)-> i32{
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

viktr

victorchukwuemeka

a day ago

2.25ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32)-> i32{
    a - b
}
pub fn multiply(a: i32, b: i32)-> i32{
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Johnchoi913

a day ago

2.28ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Moses

MosesMp3

a day ago

2.15ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    return a +b;
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32,b:i32) -> i32{
    return a-b;
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32,b:i32) -> i32 {
    return a*b;
}

Parallaxes

a day ago

2.13ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Elliott Smith

brum-b0

a day ago

2.08ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Tiago Silva

tiagombsilva

2 days ago

2.05ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    return a + b;
}
pub fn subtract(a: i32, b: i32) -> i32 {
    return a - b;
}
pub fn multiply(a: i32, b: i32) -> i32 {
    return a * b;
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

i5.650

i5-650

2 days ago

2.19ms

81.28kb

#[inline(always)]
pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
#[inline(always)]
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
#[inline(always)]
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

retinotopic

2 days ago

2.26ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    return a +b;
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b:i32) -> i32 {
    return a - b;
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b:i32) -> i32 {
    return a * b;
}

Harry Hornbacher

hhornbacher

2 days ago

2.14ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {a-b}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {a*b}

ogaca42

2 days ago

2.31ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a+b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Ustin

2 days ago

2.16ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a*b
}

Patrik Bjärterot

pbjarterot

2 days ago

2.28ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

Stefano Cianciulli

CianciuStyles

2 days ago

2.08ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Ayush Rawat

ayushrawat10

2 days ago

2.27ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Jonathan Lopez

otherJL0

2 days ago

2.21ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Smit Barve

l3vith

2 days ago

2.12ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    a+b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

damascussteel21

2 days ago

2.17ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Egor Konovalov

agegorin

2 days ago

2.11ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

daanbouwman19

2 days ago

2.20ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply (a: i32, b: i32) -> i32 {
    a * b
}

Marco Schanz

fuuman

2 days ago

2.17ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Araden14

2 days ago

2.29ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a*b
}

Oleksandr Romanov

alexromanov

2 days ago

2.10ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Laurențiu STOLERIU

LaurentiuStoleriu

2 days ago

2.19ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a*b
}

Hannes Küttner

hanneskuettner

2 days ago

2.10ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    return a + b;
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    return a - b;
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b:i32) -> i32 {
    return a * b;
}

Timepatterns

2 days ago

2.26ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a*b
}

Shubham Raizada

shbhmrzd

2 days ago

2.28ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a+b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32, b:i32) -> i32 {
    a-b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32, b:i32) -> i32 {
    a*b
}

CountJung

2 days ago

2.37ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    let ret=a+b;
    ret
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a:i32, b:i32) -> i32
{
    let ret=a-b;
    ret
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a:i32,b:i32)->i32
{
    let ret=a*b;
    ret
}

dev-puzzler

2 days ago

2.51ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

Ojash Neopane

oneopane

3 days ago

2.17ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b 
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.

Yuraima Estevez

yurm04

3 days ago

2.15ms

81.28kb

pub fn add(a: i32, b: i32) -> i32 {
    // Step 1: implement addition
    a + b
}
// Step 2:
// Define a public function named `subtract`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}
// Step 3:
// Define a public function named `multiply`
// that accepts two arguments of type `i32`
// and returns an `i32`.
// make sure you make the function public by using the `pub` keyword.
pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}