rustc-dev-guide

Pros of rust

• Contains the actual Rust compiler and standard library source code
• Provides a comprehensive test suite for the Rust language
• Allows direct contributions to the Rust language and its core components

Cons of rust

• Larger and more complex codebase, potentially harder for newcomers to navigate
• Requires a deeper understanding of Rust internals to contribute effectively
• May have a steeper learning curve for those looking to understand Rust's implementation

Code Comparison

rustc-dev-guide (documentation example):

# The `ty` module: representing types

This module defines how the Rust compiler represents types internally.

rust (actual implementation):

pub mod ty {
    use crate::mir::interpret::{AllocId, ConstValue, Scalar};
    use crate::ty::subst::{GenericArg, SubstsRef};
    // ... (more implementation details)
}

The rustc-dev-guide repository focuses on providing documentation and guidance for Rust compiler development, while the rust repository contains the actual implementation of the Rust compiler and standard library. The rustc-dev-guide is more accessible for those looking to understand the compiler's architecture, while rust is where the actual development and maintenance of the language occur.

Pros of book

• More beginner-friendly, focusing on teaching Rust from the ground up
• Covers a broader range of Rust concepts and features
• Regularly updated with new Rust releases and community feedback

Cons of book

• Less detailed information on Rust's internal workings
• Not as helpful for contributors looking to work on the Rust compiler itself
• May not cover some advanced or niche topics in depth

Code comparison

book:

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

rustc-dev-guide:

fn compile_input(input: &str) -> Result<(), Box<dyn Error>> {
    let config = rustc_interface::Config::default();
    rustc_interface::run_compiler(config, |compiler| {
        // Compiler operations here
    })
}

The book example shows a simple "Hello, world!" program, typical for beginners. The rustc-dev-guide example demonstrates a more complex function related to compiler operations, reflecting its focus on Rust's internals.

Both repositories serve different purposes within the Rust ecosystem. book is an excellent resource for learning Rust programming, while rustc-dev-guide is invaluable for those interested in contributing to Rust's compiler or understanding its inner workings. The choice between them depends on the user's goals and level of expertise in Rust.

Pros of Reference

• More comprehensive coverage of Rust language features
• Serves as the authoritative specification for the Rust language
• Regularly updated to reflect the latest stable Rust version

Cons of Reference

• Focuses solely on language features, not compiler internals
• May be more challenging for beginners to understand
• Less practical guidance for contributing to Rust development

Code Comparison

Reference:

fn main() {
    let x: i32 = 5;
    let y: i32 = 10;
    println!("x + y = {}", x + y);
}

rustc-dev-guide:

fn compile_fn(tcx: TyCtxt<'_>, def_id: DefId) {
    let body = tcx.optimized_mir(def_id);
    // ... compiler-specific code ...
}

The Reference provides examples of Rust code as it would be written by users, while the rustc-dev-guide shows internal compiler code and processes.

Summary

The Reference is ideal for understanding Rust language features and serves as the official language specification. The rustc-dev-guide, on the other hand, is more suitable for those interested in contributing to Rust's development or understanding the compiler's inner workings. While the Reference covers a broader range of topics related to the language itself, the rustc-dev-guide offers practical insights into the compiler's implementation and development process.

Pros of nomicon

• Focuses on advanced and unsafe Rust concepts, providing deeper insights
• More concise and targeted content for experienced Rust developers
• Includes detailed explanations of memory layout and low-level operations

Cons of nomicon

• Less comprehensive coverage of the Rust compiler's internals
• Not as frequently updated as rustc-dev-guide
• Lacks specific guidance for contributing to the Rust project

Code comparison

nomicon:

unsafe {
    let mut num = 5;
    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;
    *r2 += 1;
    println!("r1: {}, r2: {}", *r1, *r2);
}

rustc-dev-guide:

fn compile_crate() -> Result<(), ErrorReported> {
    let sess = ty::TyCtxt::create_global_ctxt(...);
    sess.enter(|tcx| {
        tcx.analysis(LOCAL_CRATE)
    })
}

The nomicon example demonstrates unsafe Rust and raw pointers, while the rustc-dev-guide snippet shows compiler-specific code related to type checking and analysis.

Pros of rust-by-example

• More beginner-friendly with interactive examples
• Covers a wide range of Rust concepts and features
• Provides practical, runnable code snippets

Cons of rust-by-example

• Less in-depth coverage of advanced topics
• Focuses on language features rather than compiler internals
• May not be as up-to-date with the latest Rust developments

Code comparison

rustc-dev-guide (explaining compiler internals):

fn compile_crate() -> Compilation {
    let sess = ParseSess::new(opts);
    let krate = parse::parse_crate_from_file(&input, &sess);
    // ... more compiler-specific code
}

rust-by-example (demonstrating language features):

fn main() {
    let x = 5;
    let y = if x == 5 { 10 } else { 15 };
    println!("y = {}", y);
}

The rustc-dev-guide repository is focused on explaining the internals of the Rust compiler, making it more suitable for advanced users and those interested in contributing to the compiler itself. It provides detailed information about the compilation process, data structures, and algorithms used in rustc.

On the other hand, rust-by-example is designed to teach Rust programming through interactive examples. It covers a wide range of language features and concepts, making it ideal for beginners and those looking to improve their Rust skills. The examples are concise and runnable, allowing users to experiment with the code directly in their browser.

Pros of rustlings

• More beginner-friendly, focusing on hands-on exercises
• Interactive learning experience with immediate feedback
• Covers a wide range of Rust concepts in bite-sized lessons

Cons of rustlings

• Less comprehensive coverage of Rust's internals and compiler
• Limited depth in advanced topics and language implementation details
• Doesn't provide extensive documentation on Rust's development process

Code comparison

rustlings example:

fn main() {
    let x = 5;
    println!("x has the value {}", x);
}

rustc-dev-guide example:

fn main() {
    let tcx: TyCtxt<'_> = /* ... */;
    let def_id = /* ... */;
    let ty = tcx.type_of(def_id);
}

The rustlings example focuses on basic syntax and concepts, while the rustc-dev-guide example deals with internal compiler structures and processes.

Summary

rustlings is an excellent resource for beginners learning Rust through practical exercises. It offers a more interactive and approachable learning experience compared to the rustc-dev-guide. However, it lacks the depth and comprehensive coverage of Rust's internals that the rustc-dev-guide provides. The rustc-dev-guide is better suited for those interested in understanding Rust's compiler internals and contributing to its development.