capypad
0 Tage Serie
Neues Quiz
Code-Bibliothek

Code, der lesenswert ist.

Sorgfältig kuratierte Snippets — TypeScript, Python, Rust, Go und mehr. Jedes mit einer Zeile-für-Zeile-Erklärung, damit du Code so liest, wie die Leute ihn geschrieben haben.

3498 Snippets · 10 Sprachen
▶ Lernen starten
Sammlung öffnen: Rust · Experten →
Rust · ExperteSnippet

Manuelle Send/Sync-Implementierung für FFI-Wrapper

Standardmäßig sind Typen, die Raw Pointer enthalten, weder Send noch Sync. Um sie zwischen Threads zu übergeben oder Referenzen threadübergreifend zu teilen, müssen diese Marker-Traits manuell implementiert werden. Dies erfordert einen 'unsafe'-Block, da der Compiler nicht verifizieren kann, ob die Synchronisationslogik oder das Pointer-Management korrekt ist.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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) }
    }
}
Memory ManagementPerformance
Rust · ExperteSnippet

Optimierung mit UnsafeCell

'UnsafeCell' ist der einzige legale Weg, in Rust eine mutable Referenz aus einer immutablen zu erhalten. Es ist das Primitiv hinter 'Cell' und 'RefCell'. Die direkte Verwendung ist hochgradig unsicher und erfordert, dass der Entwickler manuell garantiert, dass keine anderen Referenzen gleichzeitig existieren.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
12
13
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.
Memory ManagementPerformance
Rust · ExperteSnippet

Pinned Memory für Async State Machines

Der 'Pin'-Wrapper stellt sicher, dass ein Wert an einer festen Speicheradresse bleibt. Dies ist kritisch für selbstreferenzierende Strukturen, bei denen ein Feld einen Pointer auf ein anderes Feld im selben Objekt speichert. Wenn das Objekt verschoben würde, würde der interne Pointer ungültig.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
    }
}
Memory ManagementAsync & Concurrency
Rust · ExperteSnippet

Higher-Rank Trait Bounds (HRTB)

Higher-Rank Trait Bounds (HRTB) ermöglichen es, anzugeben, dass eine Bindung für alle möglichen Lebensdauern gilt. Die 'for<'a>'-Syntax stellt sicher, dass die Closure eine Referenz mit jeder beliebigen Lebensdauer verarbeiten kann, statt einer festen Lebensdauer beim Aufruf.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
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));
}
SyntaxFunktionen
Rust · ExperteSnippet

Generic Associated Types (GATs) für Iteration

Generic Associated Types ermöglichen es assoziierten Typen, Lebensdauer- oder Typparameter zu tragen. Dies ist essenziell für 'Lending Iteratoren', bei denen das vom Iterator gelieferte Element vom Iterator selbst leiht – ein Muster, das Standard-Iteratoren nicht effizient ausdrücken können.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
    }
}
SyntaxBest Practices
Rust · ExperteSnippet

Zero-Cost Typestate-Pattern mit PhantomData

Das Typestate-Pattern nutzt Rusts Typsystem, um Zustandsübergänge zur Kompilierzeit zu erzwingen. Durch die Verwendung von PhantomData können wir Zustände unterscheiden, ohne Laufzeit-Speicher-Overhead zu verursachen. Dies stellt sicher, dass Methoden wie 'process' nur aufgerufen werden können, wenn die Daten den Zustand 'Checked' erreicht haben.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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);
    }
}
SyntaxBest Practices
Rust · ExperteSnippet

Datenparallelität mit Portable SIMD

Portable SIMD (Single Instruction, Multiple Data) ermöglicht es, Operationen auf mehreren Werten gleichzeitig mittels CPU-Vektorinstruktionen auszuführen. Durch das Packen von vier f32-Werten in ein einzelnes f32x4-Register können Additionen parallel ausgeführt werden, was die Leistung bei numerischen Berechnungen erheblich steigert.

snippet.rs
rust
1
2
3
4
5
6
7
8
9
10
11
#![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()
}
PerformanceArrays & Listen
Rust · ExperteSnippet

Lifetime-Varianz und Kovarianz in Referenzen

Varianz bestimmt, wie das Subtyping zwischen Lifetimes die Kompatibilität komplexer Typen beeinflusst. Unveränderliche Referenzen sind kovariant über ihre Lifetime, was bedeutet, dass man eine längerlebige Referenz an eine Funktion übergeben kann, die eine kürzere erwartet. Veränderliche Referenzen sind hingegen invariant, um Speicherunsicherheit zu vermeiden.

snippet.rs
rust
1
2
3
4
5
6
7
8
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
}
Memory ManagementSyntax