rust 11 lines · 1 tab

Trait bounds for generic functions with behavior constraints

Marcus Chen Jan 2026

1 tab

use std::fmt::Display;

fn print_it<T: Display>(value: T) {
    println!("Value: {}", value);
}

fn main() {
    print_it(42);
    print_it("hello");
    print_it(3.14);
}

1 file · rust Explain with highlit

Traits define shared behavior, and trait bounds let you write generic functions that work with any type implementing a trait. The syntax T: Display means "T must implement Display." This is similar to interfaces in other languages but more powerful: you can implement traits for types you don't own, and trait bounds are zero-cost (monomorphization at compile time). I use trait bounds everywhere: for serialization (T: Serialize), for comparison (T: Ord), for cloning (T: Clone). The compiler generates specialized code for each concrete type, so there's no dynamic dispatch unless you opt in with dyn Trait. This pattern is the foundation of Rust's generic programming model.

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.

Trait bounds for generic functions with behavior constraints — share card

Link copied