Skip to main content
ubuntuask.com

Back to all posts

How to Store A Closure Inside Rust Struct?

Published on
3 min read
How to Store A Closure Inside Rust Struct? image

Best Rust Programming Books to Buy in October 2025

1 The Rust Programming Language, 2nd Edition

The Rust Programming Language, 2nd Edition

BUY & SAVE
$30.13 $49.99
Save 40%
The Rust Programming Language, 2nd Edition
2 Programming Rust: Fast, Safe Systems Development

Programming Rust: Fast, Safe Systems Development

BUY & SAVE
$43.99 $79.99
Save 45%
Programming Rust: Fast, Safe Systems Development
3 Rust for Rustaceans: Idiomatic Programming for Experienced Developers

Rust for Rustaceans: Idiomatic Programming for Experienced Developers

BUY & SAVE
$29.99 $49.99
Save 40%
Rust for Rustaceans: Idiomatic Programming for Experienced Developers
4 Rust in Action

Rust in Action

BUY & SAVE
$51.42 $59.99
Save 14%
Rust in Action
5 Rust Programming: A Practical Guide to Fast, Efficient, and Safe Code with Ownership, Concurrency, and Web Programming (Rheinwerk Computing)

Rust Programming: A Practical Guide to Fast, Efficient, and Safe Code with Ownership, Concurrency, and Web Programming (Rheinwerk Computing)

BUY & SAVE
$47.06 $59.95
Save 22%
Rust Programming: A Practical Guide to Fast, Efficient, and Safe Code with Ownership, Concurrency, and Web Programming (Rheinwerk Computing)
6 Zero To Production In Rust: An introduction to backend development

Zero To Production In Rust: An introduction to backend development

BUY & SAVE
$49.99
Zero To Production In Rust: An introduction to backend development
7 The Rust Programming Language

The Rust Programming Language

BUY & SAVE
$16.92 $39.95
Save 58%
The Rust Programming Language
+
ONE MORE?

In Rust, it is possible to store a closure inside a struct by using the Fn trait. Closures in Rust are represented by anonymous types that implement the Fn trait or one of its subtraits (FnMut, FnOnce). To store a closure inside a struct, you can define a struct with a field that holds a closure type. For example:

struct MyStruct<F: Fn(i32) -> i32> { closure: F, }

impl<F: Fn(i32) -> i32> MyStruct { fn new(closure: F) -> Self { MyStruct { closure } }

fn call\_closure(&self, x: i32) -> i32 {
    (self.closure)(x)
}

}

In this example, MyStruct is a generic struct that takes a closure type F as a parameter. The new function initializes the struct with a closure, and the call_closure function can be used to call the stored closure with an argument.

When creating an instance of MyStruct, you can pass a closure as a parameter:

let my_struct = MyStruct::new(|x| x * 2); let result = my_struct.call_closure(3); println!("Result: {}", result); // Output: Result: 6

This way, you can store and use closures inside a Rust struct effectively.

How to pass a closure as a parameter in Rust?

To pass a closure as a parameter in Rust, you can define a generic parameter with the Fn trait bound. Here's an example of how you can pass a closure as a parameter in Rust:

fn apply_closure(closure: F) where F: Fn(i32) -> i32, { let result = closure(5); println!("Result: {}", result); }

fn main() { let add_5 = |x: i32| x + 5;

apply\_closure(add\_5);

}

In this example, the apply_closure function takes a closure as a parameter with the type F: Fn(i32) -> i32. The main function defines a closure add_5 that adds 5 to the input argument, and then passes this closure to the apply_closure function, which applies the closure to the value 5.

How to declare a struct in Rust?

To declare a struct in Rust, you can use the struct keyword followed by the struct name and define the fields inside curly braces. Here's an example:

struct Person { name: String, age: u32, is_adult: bool, }

In this example, we define a Person struct with three fields: name of type String, age of type u32, and is_adult of type bool. You can then create instances of this struct and access its fields like this:

let person1 = Person { name: String::from("Alice"), age: 30, is_adult: true, };

println!("{} is {} years old", person1.name, person1.age);

What is the scope of a closure stored inside a struct in Rust?

The scope of a closure stored inside a struct in Rust is determined by the lifetime of the struct itself. The closure can capture references to variables defined outside of its scope, but it cannot outlive the struct in which it is stored. This means that the closure can only be called while the struct is still alive and in scope. If the struct is dropped or goes out of scope, any captured references will become invalid, and trying to call the closure will result in a compilation error.