Rust impl Trait

Rust – Build Scripts

Last Updated : 26 Apr, 2025

In Rust, there is an option for building scripts where Cargo compiles a built script into an executable file, and after running the script, many tasks can be performed. There are scenarios where we need different options for generating a code before it’s built. The cargo compiler in this case compiles the script and integrates it with build scripts.

To execute this step, we need to declare a build.rs file in the root directory.

Example:

In this example, we declare a file build.rs

In the main.rs file, the code is:

Rust

include!(concat!(env!("OUT_DIR"), "/gfg.rs")); 
  
fn main() { 
    println!("Printing: {}", message()); 
} 

In the build.rs, the code is:

Rust

use std::env; 
use std::fs; 
use std::path::Path; 
  
fn main() { 
    let out_dir = env::var_os("OUT_DIR").unwrap(); 
    let dest_path = Path::new(&out_dir).join("gfg.rs"); 
    fs::write( 
        &dest_path, 
        "pub fn message() -> &'static str { 
            \"Geeks for Geeks!\" 
        } 
        " 
    ).unwrap(); 
    println!("cargo:rerun-if-changed=build.rs"); 
} 

Output:

For getting the output, we put cargo run

Explanation:

In the main.rs file, we have declared an expression include! concat! and env! which means that the library build.rs is defined in the rust module and once we use the concat! macro and the env! macro the gfg.rs file is generated for the rust crate to compile.

In the build.rs file, the Out_dir envt variable is declared for knowing the location of the output files. Also, the rerun-if-changed instruction tells cargo that the scripts would be re-run in case the build script is changed and this line ensures that cargo automatically runs if any build script changes with a change in the package.

Rust impl Trait

S

sayanc170

Improve

Article Tags :

Similar Reads

Rust impl Trait

In Rust, there is a concept of impl trait. Â impl Trait is used to implement functionality for types and is generally used in function argument positions or return positions. It is used in scenarios where our function returns a single type value. In the impl trait, we always specify the impl keyword

A trait tells the Rust compiler about functionality a particular type has and can share with other types. Traits are an abstract definition of shared behavior amongst different types. So, we can say that traits are to Rust what interfaces are to Java or abstract classes are to C++. A trait method is

Rust - Drop Trait

Drop trait lets us customize what happens when a value is about to go out of scope. Drop trait is important to the smart pointer pattern. Drop trait functionality is used when implementing a smart pointer. For example, Box<T> customizes Drop to deallocate the space on the heap that the box poi

String data type is a very important part of any programming language. Rust handles strings a bit differently from other languages. The String data type in Rust is of two types: String Literal (&str)String Object (String)String LiteralString Literal or &str are called 'string slices', which

Rust - Generic Traits

Rust is an extremely fast programming language that supports speed, concurrency, as well as multithreading. In Rust, we have a concept of Generic Traits where Generics are basically an abstraction of various properties, and Traits are basically used for combining generic types for constraining types

Rust - Clone Trait

In Rust, we have a concept of clone trait. Clone traits have the ability to duplicate objects explicitly. We can make anything copy with the Clone Trait. Syntax: //pub refers to public trait pub trait Clone {Â Â fn clone(&self) -> Self; Â Â fn clone_from_trait(&mut self, source: &Self) { ... }} In Rus

Rust - Supertraits

In Rust, we have a concept of super traits. Rust being a modern systems-based programming language focuses mainly on the speed, safe and concurrent aspects of programming. Supertraits in Rust are traits that require implementation for conversion of specific types for implementing specific traits. As

Rust - Deref Trait

Deref<T> trait in Rust is used for customizing dereferencing operator (*) behavior. Implementing the Deref <T> treats the smart pointer as a reference. Therefore, any code that references the deref trait would also refer to smart pointers. Regular References in Deref Trait:Regular refere

Bash Script - Features

These days, there are various shell writing options available out there, and each one of them has its own unique features. Just as it does, Bash Shell contains some of the best features that make it more productive and usable. For each project, there are specific requirements for the features, and t

In Rust, there are specific procedures that are needed to be adhered to before writing the tests. The steps for writing the tests are as follows: Step 1: Setting up data/states required by our code. Step 2: Run the code for the tests we need to test. Step 3: Asserting the expected results. In Rust,