Rust Functions Quiz

Rust

0 Passed

0% acceptance

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

40 Questions

~80 minutes

Question 1

What is the syntax for defining a function in Rust?

fn function_name() { ... }

function function_name() { ... }

def function_name() { ... }

func function_name() { ... }

Question 2

How do you specify parameters in a Rust function?

fn add(x: i32, y: i32) -> i32 { x + y }

fn add(x, y: i32) -> i32 { x + y }

fn add(x: i32, y) -> i32 { x + y }

fn add(x y: i32) -> i32 { x + y }

Question 3

What does the -> syntax indicate in a function signature?

The return type of the function

A reference parameter

An arrow function

A closure

Question 4

What happens if you don't specify a return type for a function?

It returns () (unit type)

Compilation error

It returns the last expression

It returns i32 by default

Question 5

How do you explicitly return a value from a function?

Use the return keyword or omit semicolon on last expression

Only use the return keyword

Only omit semicolon on last expression

Use the yield keyword

Question 6

What is a statement in Rust?

An expression that returns a value

An instruction that performs an action but doesn't return a value

A function call

A variable declaration

Question 7

What is an expression in Rust?

An instruction that performs an action

Code that evaluates to a value

A function definition

A variable assignment

Question 8

Can function bodies contain both statements and expressions?

Yes, statements perform actions, expressions return values

No, only expressions are allowed

No, only statements are allowed

Only in certain contexts

Question 9

What will this function return?

rust

fn example() -> i32 {
    let x = 5;
    x + 1
}

()

Compilation error

Question 10

What will this function return?

rust

fn example() -> i32 {
    let x = 5;
    x + 1;
}

()

Compilation error

Question 11

What are diverging functions in Rust?

Functions that never return to the caller

Functions that return multiple values

Functions that take variable arguments

Functions that modify their parameters

Question 12

What is the return type of a diverging function?

()

Option<T>

Result<T, E>

Question 13

Which of these is an example of a diverging function?

fn panic_function() -> ! { panic!(); }

fn loop_forever() -> ! { loop {} }

fn exit_program() -> ! { std::process::exit(0); }

All of the above

Question 14

How does function scope affect variable lifetime?

Variables live until the end of their scope

Variables live for the entire program

Variables are garbage collected

Variables live until explicitly dropped

Question 15

What happens to variables when a function returns?

They are dropped in reverse order of creation

They remain in memory

They are moved to the caller

They become invalid

Question 16

Can functions be defined inside other functions?

Yes, as nested functions

No, functions can only be defined at module level

Only in certain contexts

Only anonymous functions can be nested

Question 17

What is the scope of a variable declared inside a function?

From its declaration until the end of the function

Global scope

Until the next function call

Until explicitly freed

Question 18

How do you pass ownership of a value to a function?

By passing the value directly

By using &mut

By using &

By cloning

Question 19

How do you allow a function to borrow a value without taking ownership?

Use & in the parameter type

Use mut in the parameter

Pass by value

Use Box<T>

Question 20

What happens to borrowed values when a function returns?

They remain borrowed by the caller

They are moved to the caller

They are dropped

They become owned by the caller

Question 21

Can a function modify a borrowed value?

Only if it's &mut

Yes, always

No, never

Only for primitive types

Question 22

What is the difference between String and &str parameters?

String takes ownership, &str borrows

They are the same

&str takes ownership, String borrows

String is for literals, &str for owned strings

Question 23

When should you use &str instead of String in function parameters?

When you only need to read the string

When you need to modify the string

When you need to return the string

When the string is very long

Question 24

What will this function do?

rust

fn take_ownership(s: String) {
    println!("{}", s);
} // s is dropped here

Print the string and drop it

Print the string and return it

Move the string to the caller

Borrow the string temporarily

Question 25

What will this function do?

rust

fn borrow_string(s: &String) {
    println!("{}", s);
} // s remains borrowed

Print the string and drop it

Print the string and keep it borrowed

Take ownership of the string

Modify the string

Question 26

How do you return a value from a function while maintaining ownership?

Return the value directly

Use references

Use Rc<T>

Use Box<T>

Question 27

What happens if you try to return a reference to a local variable?

Compilation error - cannot return references to locals

The reference is automatically extended

The local variable is moved

Runtime error

Question 28

How can you return a string from a function?

fn get_string() -> String { String::from("hello") }

fn get_string() -> &str { "hello" }

fn get_string() -> String { &String::from("hello") }

Both A and B work

Question 29

What is function overloading in Rust?

Defining multiple functions with the same name but different parameters

Defining functions with variable arguments

Not supported in Rust

Using generics for different types

Question 30

How does Rust handle functions with the same name?

Compilation error

Last definition wins

They are overloaded

They must be in different modules

Question 31

What are generic functions in Rust?

Functions that work with multiple types

Functions that take variable arguments

Functions that can be overloaded

Functions that return any type

Question 32

What is the syntax for generic functions?

fn generic<T>(value: T) { ... }

fn generic(value: T) { ... }

fn generic(value) { ... }

fn generic(value: any) { ... }

Question 33

Can functions have multiple generic parameters?

Yes, fn func<T, U>(t: T, u: U)

No, only one generic parameter allowed

Only for structs

Only for traits

Question 34

What are trait bounds in generic functions?

Constraints on what types can be used

Limits on function size

Memory bounds

Performance bounds

Question 35

What is the syntax for trait bounds?

fn func<T: Display>(value: T)

fn func<T where T: Display>(value: T)

Both A and B

fn func(value: T where T: Display)

Question 36

What happens if you call a diverging function?

The program terminates or loops forever

The function returns a value

The caller continues execution

Memory is leaked

Question 37

How can diverging functions be useful?

For error handling and program termination

For returning multiple values

For performance optimization

For memory management

Question 38

What is the scope hierarchy in Rust?

Function > Block > Module > Crate

Module > Function > Block > Crate

Crate > Module > Function > Block

Block > Function > Module > Crate

Question 39

Can inner scopes access variables from outer scopes?

Yes, but they cannot modify them unless mutable

No, scopes are completely isolated

Only for global variables

Only for constants

Question 40

What happens to variables shadowed in inner scopes?

The outer variable is temporarily inaccessible

The outer variable is dropped

Compilation error

The inner variable replaces the outer one permanently

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations