rust 15 lines · 1 tab

impl Trait for opaque return types

Marcus Chen Jan 2026

1 tab

use std::fmt::Display;

fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

fn format_value(val: i32) -> impl Display {
    format!("Value: {}", val)
}

fn main() {
    let add_five = make_adder(5);
    println!("{}", add_five(10));
    println!("{}", format_value(42));
}

1 file · rust Explain with highlit

impl Trait in return position lets you return a type that implements a trait without naming it. This is useful for closures, iterators, or futures where the concrete type is complex or unnameable. The caller only knows it implements the trait. I use impl Trait for iterator chains (impl Iterator<Item=T>), async functions (which return impl Future), and anywhere the concrete type is an implementation detail. It's more ergonomic than Box<dyn Trait> because there's no heap allocation or dynamic dispatch. The limitation is that you can only return one concrete type (no branching between types). For multiple types, use trait objects or enums.

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.

impl Trait for opaque return types — share card

Link copied