Code, der lesenswert ist.

struct RawBuffer {
    ptr: *mut u8,
    len: usize,
}
 
// SAFETY: We ensure that access to the buffer is synchronized
// and that the pointer is valid for the duration of its use.
unsafe impl Send for RawBuffer {}
unsafe impl Sync for RawBuffer {}
 
impl RawBuffer {
    pub fn as_slice(&self) -> &[u8] {
        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
    }
}

use std::cell::UnsafeCell;
 
struct MyCell<T> {
    value: UnsafeCell<T>,
}
 
impl<T> MyCell<T> {
    pub fn get_mut_unsafe(&self) -> &mut T {
        unsafe { &mut *self.value.get() }
    }
}
 
// Usage is dangerous and requires strict manual tracking of borrows.

use std::pin::Pin;
use std::marker::PhantomPinned;
 
struct SelfReferential {
    data: String,
    ptr: *const String,
    _pin: PhantomPinned,
}
 
impl SelfReferential {
    pub fn new(data: String) -> Pin<Box<Self>> {
        let res = SelfReferential {
            data,
            ptr: std::ptr::null(),
            _pin: PhantomPinned,
        };
        let mut boxed = Box::pin(res);
        let self_ptr: *const String = &boxed.data;
        unsafe {
            let mut_ref: Pin<&mut Self> = boxed.as_mut();
            Pin::get_unchecked_mut(mut_ref).ptr = self_ptr;
        }
        boxed
    }
}

fn process_data<F>(data: &str, handler: F)
where
    F: for<'a> Fn(&'a str),
{
    handler(data);
}
 
fn main() {
    process_data("expert", |s| println!("Processing: {}", s));
}

trait LendingIterator {
    type Item<'a> where Self: 'a;
    
    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}
 
struct MyStream(Vec<u32>);
 
impl LendingIterator for MyStream {
    type Item<'a> = &'a u32;
    
    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>> {
        self.0.get(0) // Simplified logic
    }
}

use std::marker::PhantomData;
 
struct Unchecked;
struct Checked;
 
struct Data<S> {
    value: String,
    _state: PhantomData<S>,
}
 
impl Data<Unchecked> {
    fn new(v: &str) -> Self { 
        Data { value: v.into(), _state: PhantomData }
    }
    
    fn validate(self) -> Data<Checked> {
        // Perform complex validation logic here
        Data { value: self.value, _state: PhantomData }
    }
}
 
impl Data<Checked> {
    fn process(&self) {
        println!("Processing validated data: {}", self.value);
    }
}

#![feature(portable_simd)]
use std::simd::f32x4;
 
fn fast_add(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
    let va = f32x4::from_array(a);
    let vb = f32x4::from_array(b);
    
    let sum = va + vb; // Executes a single SIMD instruction (e.g., ADDPS)
    
    sum.to_array()
}

fn subtyping_demo<'a, 'b: 'a>(short: &'a str, long: &'b str) {
    // &'b str is a subtype of &'a str because 'b outlives 'a
    let x: &'a str = long; // Covariance: we can use a longer lifetime where a shorter is expected
    
    // This would fail if we used mutable references:
    // let mut m_long: &'b str = "...";
    // let r: &mut &'a str = &mut m_long; // Error: &mut T is invariant over T
}