codesnips
rust 13 lines · 1 tab

mod and pub for code organization and visibility

Marcus Chen Jan 2026
1 tab 
mod utils {
    pub fn helper() {
        println!("Helper function");
    }

    fn private_fn() {}
}

pub use utils::helper;

pub fn public_api() {
    helper();
}
1 file · rust Explain with highlit

Rust's module system uses mod to define modules and pub to control visibility. Modules can be inline (mod name { ... }) or in separate files (mod name; loads name.rs). By default, items are private; use pub to expose them. I organize code into modules by feature or layer (controllers, models, services). pub(crate) makes items public within the crate but private externally. For nested modules, use super::* or use crate::module::Item imports. The pub use re-export pattern creates a clean public API. Rust's module system enforces encapsulation and makes refactoring safer.

Related snips

rust 
struct Config<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_config(line: &str) -> Config {

Lifetime annotations for flexible borrowing in structs

rust lifetimes borrowing
by Marcus Chen 1 tab
rust 
use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free
by Marcus Chen 1 tab
rust 
use tracing::{info, instrument};

#[instrument]
fn process_request(user_id: u64) {
    info!(user_id, "Processing request");
    // Work happens here

tracing for structured logging and distributed tracing

rust observability tracing
by Marcus Chen 1 tab
rust 
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

Channels (mpsc) for message passing between threads

rust concurrency channels
by Marcus Chen 1 tab
rust 
use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    #[arg(short, long)]

clap for CLI argument parsing with derive macros

rust cli clap
by Marcus Chen 1 tab
rust 
macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Called {}", stringify!($func_name));
        }
    };

Declarative macros (macro_rules!) for code generation

rust macros metaprogramming
by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

mod and pub for code organization and visibility — share card
Link copied