HTML Tutorial Rust Tutorial JavaScript Tutorial Python Tutorial AI Tutorial
Login Register
×

Rust Packages and Crates

by
Previous
Next

What Are Crates in Rust?

A crate in Rust is a package of Rust code that the compiler can compile. It is the basic building block of Rust programs. Every Rust program is made up of at least one crate. Crates help organize code, reuse functionality, and share code across projects.

There are two main types of crates:

  1. Binary Crates:
    • These produce an executable program.
    • They always have a main function, which is the starting point of the program.
    • Example: Command-line tools or any Rust program you run.
  2. Library Crates:
    • These are collections of reusable code.
    • They do not have a main function.
    • Other programs can use them by importing the crate.
    • Example: serde, a library for converting data between formats.

Example: Creating a Binary Crate

You use cargo new my_binary to create a new Rust project. By default, this creates a binary crate because it has a main.rs file.

  • Cargo.toml → Contains metadata about the project (like name, version, dependencies).
  • src/main.rs → The main source file that runs when you execute the program.

Initialize a New Binary Crate

cargo new my_binary
cd my_binary

File Structure

my_binary/
├── Cargo.toml
└── src/
    └── main.rs

Code in main.rs

fn main() {
    println!("Hello, world!");
}

Run the Program using this command:

cargo run

Output:

Hello, world!
  • This confirms your binary crate is working and executable.

Example: Creating a Library Crate

  • cargo new my_library –lib → Creates a new Rust project as a library instead of a binary.
  • Library crates don’t have a main.rs because they are not meant to run directly. They provide reusable code.

Initialize a New Library Crate Using the following command:

cargo new my_library --lib
cd my_library

File Structure

Code in lib.rs

pub fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

Using the Library in Another Crate

  • Add your library as a dependency in the other crate’s Cargo.toml:
[dependencies]
my_library = { path = "../my_library" }
  • Import and use the function in your main.rs:
use my_library::greet;

fn main() {
    let message = greet("Rust");
    println!("{}", message);
}

Output:

Hello, Rust!

What Are Packages in Rust?

A package is like a container that holds one or more crates. It’s managed by Cargo, Rust’s official package manager.

Every package must have at least one crate, either a binary crate (an executable program) or a library crate (reusable code). Packages help you organize, share, and manage crates easily.

Structure of a Package

A Rust package looks like this:

  • Cargo.toml: Contains package information and dependencies.
  • Crates: Implement the actual code (functions, structs, etc.).

What are Dependencies and the Cargo.toml File?

In Rust, Cargo.toml is like the “control center” of a package. It tells Cargo everything about your project, such as:

  • Package Metadata: Name, version, authors, etc.
  • Dependencies: Other crates your project needs to work.
  • Build Configurations: Optional settings for compiling your project.

A dependency is an external crate (library) that you want to use in your project.

Example: Using a Random Number Generator

Cargo.toml (adding dependency):

[dependencies]
rand = "0.8"

Main.rs:

use rand::Rng;  // Import the functionality

fn main() {
    let mut rng = rand::thread_rng();       // Create random number generator
    let lucky_number: u32 = rng.gen_range(1..101); // Generate number 1 to 100
    println!("Your lucky number is: {}", lucky_number);
}

Output:

Your lucky number is: 57

How To Publishing a Crate?

Publishing a crate in Rust is making your library or project available for others to use via the official Rust package registry, Crates.io.

Steps to Publish a Crate

Create an account on Crates.io – You need an account to share your crate with the Rust community. You can log in using GitHub.

  • Visit Crates.io and log in using your GitHub account.

Login via Cargo – Cargo (Rust’s package manager) needs your API token from Crates.io to verify your account. You do this with:

cargo login <your-api-token>

Ensure Your Cargo.toml Has Necessary Metadata

[package]
name = "my_library"
version = "0.1.0"
authors = ["Your Name <your.email@example.com>"]
description = "A library for awesome features"
license = "MIT"

Publish the Crate

cargo publish

Mini Project: Random Name Generator for Students

Create a small Rust program that picks a random student name from a list. It uses a dependency (rand) to generate random numbers, and organizes code into modules and structs.

Step 1: Setup Cargo Project

cargo new student_name_generator
cd student_name_generator

Add the dependency in Cargo.toml:

[dependencies]
rand = "0.8"

Step 2: Create Modules and Structs

src/main.rs

mod students; // Import our module

use students::StudentList;

fn main() {
    // Create a list of students
    let mut my_class = StudentList::new();
    my_class.add_student("Alice");
    my_class.add_student("Bob");
    my_class.add_student("Charlie");
    my_class.add_student("Diana");

    // Pick a random student
    let chosen = my_class.pick_random();
    println!("Today's chosen student is: {}", chosen);
}

src/students.rs

use rand::Rng;

pub struct StudentList {
    names: Vec<String>, // Vector to store student names
}

impl StudentList {
    // Create a new empty list
    pub fn new() -> StudentList {
        StudentList { names: Vec::new() }
    }

    // Add a student name
    pub fn add_student(&mut self, name: &str) {
        self.names.push(String::from(name));
    }

    // Pick a random student
    pub fn pick_random(&self) -> &str {
        let mut rng = rand::thread_rng();
        let index = rng.gen_range(0..self.names.len());
        &self.names[index]
    }
}

Output of this program:

  • In this code, StudentList struct stores all student names.
  • add_student allows you add names to the list.
  • pick_random uses the rand crate to select a random name.
  • Modules organize code (students.rs) and keep main.rs clean.

Learn More About Rust Programming

Previous
Next