Learning Rust
gitbook
gitbookPrimary version
gitbook
gitbookPrimary version
  • Introduction
  • Basics
    • Why Rust
    • Installation
    • Hello World
    • Cargo,crates and basic project structure
    • Comments and documenting the code
    • Variable bindings, constants and statics
    • Functions
    • Primitive data types
    • Operators
    • Control flows
  • Beyond The Basics
    • Vectors
    • Structs
    • Enums
    • Generics
    • Impls and traits
  • The Tough Part
    • Ownership
    • Borrowing
    • Lifetimes
  • Lets Get It Started
    • Code organization
    • Functions
    • Modules
    • Crates
    • Workspaces
    • use
    • std, primitives and preludes
Powered by GitBook
On this page
  • Cargo
  • Crate
  • Project Structure
  1. Basics

Cargo,crates and basic project structure

PreviousHello WorldNextComments and documenting the code

Last updated 6 years ago

Cargo

Cargo is Rust’s built-in Package Manager. But mainly it uses for,

  • Create new project : cargo new

  • Update dependencies : cargo update

  • Build project : cargo build

  • Build and run a project : cargo run

  • Run tests : cargo test

  • Generate documentation via rustdoc : cargo doc

Other than that there are some cargo commands, especially for publishing crates directly via cargo.

  • cargo login : acquiring an API token

  • cargo package : make the local create uploadable to crates.io

  • cargo publish : make the local create uploadable to crates.io and upload the crate

Crate

⭐️ A crate is a package. Crates can be shared via .

A crate can produce an executable or a library. In other words, it can be a binary crate or a library crate. 01. cargo new crate_name --bin : produces an executable 02. cargo new crate_name --lib OR cargo new crate_name: produces a library

The first one generates,

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

and the second one generates,

├── Cargo.toml
└── src
    └── lib.rs

  • Cargo.toml(capital c) is the configuration file which contains all of the metadata that Cargo needs to compile your project.

  • src folder is the place to store the source code.

  • Each crate has an implicit crate root/ entry point. main.rs is the crate root for a binary crate and lib.rs is the crate root for a library crate.

💡 When we build a binary crate via cargo build or cargo run, the executable file will be stored in target/debug/ folder. But when build it via cargo build --release for a release it will be stored in target/release/ folder.

Project Structure

.
├── Cargo.lock
├── Cargo.toml
├── benches
│   └── large-input.rs
├── examples
│   └── simple.rs
├── src
│   ├── bin
│   │   └── another_executable.rs
│   ├── lib.rs
│   └── main.rs
└── tests
    └── some-integration-tests.rs

  • Source code goes in the src directory.

  • The default library file is src/lib.rs.

  • The default executable file is src/main.rs.

  • Other executables can be placed in src/bin/*.rs.

  • Integration tests go in the tests directory (unit tests go in each file they're testing).

  • Examples go in the examples directory.

  • Benchmarks go in the benches directory.

This is how about the recommended Project Layout,

Cargo
Cargo Docs describes