// This doesn't compile
struct Container<T> {
    data: Vec<u8>,
    // T is never used - compiler error: parameter `T` is never used
}
 
// This compiles
use std::marker::PhantomData;
 
struct Container<T> {
    data: Vec<u8>,
    _marker: PhantomData<T>,  // Tells compiler we "use" T
}
 
fn main() {
    let c: Container<String> = Container {
        data: vec![1, 2, 3],
        _marker: PhantomData,
    };
}

use std::marker::PhantomData;
use std::mem::size_of;
 
struct WithPhantom<T> {
    data: u32,
    marker: PhantomData<T>,
}
 
struct WithoutPhantom {
    data: u32,
}
 
fn main() {
    println!("WithPhantom<String>: {} bytes", size_of::<WithPhantom<String>>());
    println!("WithPhantom<u64>: {} bytes", size_of::<WithPhantom<u64>>());
    println!("WithoutPhantom: {} bytes", size_of::<WithoutPhantom>());
    
    // All three print 4 bytes (size of u32)
    // PhantomData is truly zero-sized
}

use std::marker::PhantomData;
 
// Covariant in T (default PhantomData behavior)
struct Covariant<T> {
    marker: PhantomData<T>,
}
 
// Contravariant in T
struct Contravariant<T> {
    marker: PhantomData<fn(T)>,
}
 
// Invariant in T
struct Invariant<T> {
    marker: PhantomData<fn(T) -> T>,
}
 
// Variance determines when one type can be used in place of another
fn covariance() {
    let longer: Covariant<&'static str> = Covariant { marker: PhantomData };
    let shorter: Covariant<&'static str> = longer;  // &'static str can become &'a str
    
    // &'static str is a subtype of &'a str (longer lifetime is more permissive)
    // So Covariant<&'static str> can be assigned to Covariant<&'a str>
}
 
fn contravariance() {
    // fn(&'static str) is a subtype of fn(&'a str)
    // Contravariance flips the relationship
}
 
fn invariance() {
    // Invariant types cannot be substituted at all
    // Necessary for interior mutability and other patterns
}

use std::marker::PhantomData;
 
// Acts as if it owns a T
struct Owns<T> {
    marker: PhantomData<T>,
}
 
// Acts as if it holds a reference to T
struct References<'a, T> {
    marker: PhantomData<&'a T>,
}
 
// Acts as if it holds a mutable reference to T
struct MutReferences<'a, T> {
    marker: PhantomData<&'a mut T>,
}
 
// Acts as if it holds a Box<T>
struct Boxes<T> {
    marker: PhantomData<Box<T>>,
}
 
fn main() {
    // Owns<T> drops T when it drops (if T: Drop)
    // References<'a, T> requires T lives for 'a
    // The marker affects lifetime bounds and drop behavior
}

use std::marker::PhantomData;
 
struct DropCheck<T> {
    marker: PhantomData<T>,
}
 
struct HasDrop;
 
impl Drop for HasDrop {
    fn drop(&mut self) {
        println!("HasDrop dropped");
    }
}
 
fn main() {
    // DropCheck<HasDrop> doesn't actually drop HasDrop
    // PhantomData affects variance, not actual drop behavior
    // But it tells the compiler about drop checking obligations
    
    let _: DropCheck<HasDrop> = DropCheck { marker: PhantomData };
    // HasDrop::drop is NOT called because there's no actual HasDrop
    
    // However, DropCheck<HasDrop> cannot outlive HasDrop's validity
}

use std::marker::PhantomData;
 
// Tag for different units at type level
struct Meters;
struct Feet;
 
struct Distance<Unit> {
    value: f64,
    _marker: PhantomData<Unit>,
}
 
impl Distance<Meters> {
    fn from_meters(m: f64) -> Self {
        Distance { value: m, _marker: PhantomData }
    }
}
 
impl Distance<Feet> {
    fn from_feet(f: f64) -> Self {
        Distance { value: f, _marker: PhantomData }
    }
}
 
// Can only add same units
impl<Unit> std::ops::Add for Distance<Unit> {
    type Output = Distance<Unit>;
    
    fn add(self, other: Distance<Unit>) -> Distance<Unit> {
        Distance {
            value: self.value + other.value,
            _marker: PhantomData,
        }
    }
}
 
// Conversions between units
impl Distance<Meters> {
    fn to_feet(self) -> Distance<Feet> {
        Distance {
            value: self.value * 3.28084,
            _marker: PhantomData,
        }
    }
}
 
fn main() {
    let m1 = Distance::from_meters(10.0);
    let m2 = Distance::from_meters(5.0);
    let meters = m1 + m2;  // OK: Distance<Meters>
    
    let f1 = Distance::from_feet(30.0);
    // let error = m1 + f1;  // Won't compile: different units
    
    let feet = meters.to_feet();  // OK: conversion
    
    println!("{} meters", meters.value);  // Actually errors - meters moved
}

use std::marker::PhantomData;
 
// States
struct Idle;
struct Connected;
struct Authenticated;
 
struct Connection<State> {
    stream: Option<String>,  // Simplified - would be actual stream
    _state: PhantomData<State>,
}
 
impl Connection<Idle> {
    fn new() -> Self {
        Connection {
            stream: None,
            _state: PhantomData,
        }
    }
    
    fn connect(self, address: &str) -> Connection<Connected> {
        Connection {
            stream: Some(format!("connected to {}", address)),
            _state: PhantomData,
        }
    }
}
 
impl Connection<Connected> {
    fn authenticate(self, credentials: &str) -> Connection<Authenticated> {
        Connection {
            stream: self.stream,
            _state: PhantomData,
        }
    }
    
    fn disconnect(self) -> Connection<Idle> {
        Connection {
            stream: None,
            _state: PhantomData,
        }
    }
}
 
impl Connection<Authenticated> {
    fn send_data(&self, data: &str) {
        println!("Sending: {}", data);
    }
    
    fn disconnect(self) -> Connection<Idle> {
        Connection {
            stream: None,
            _state: PhantomData,
        }
    }
}
 
fn main() {
    let conn = Connection::new();
    
    // Cannot call send_data here - not authenticated
    
    let conn = conn.connect("example.com");
    // Cannot call send_data here - not authenticated
    
    let conn = conn.authenticate("secret");
    conn.send_data("Hello!");  // OK: now authenticated
    
    // Type system enforces state machine transitions
}

use std::marker::PhantomData;
 
// Different index types
struct VertexIndex;
struct EdgeIndex;
 
struct Index<T> {
    idx: usize,
    _marker: PhantomData<T>,
}
 
struct Graph {
    vertices: Vec<String>,
    edges: Vec<(usize, usize)>,
}
 
impl Graph {
    fn add_vertex(&mut self, name: String) -> Index<VertexIndex> {
        let idx = self.vertices.len();
        self.vertices.push(name);
        Index { idx, _marker: PhantomData }
    }
    
    fn add_edge(&mut self, from: Index<VertexIndex>, to: Index<VertexIndex>) -> Index<EdgeIndex> {
        let idx = self.edges.len();
        self.edges.push((from.idx, to.idx));
        Index { idx, _marker: PhantomData }
    }
    
    fn get_vertex(&self, idx: Index<VertexIndex>) -> &str {
        &self.vertices[idx.idx]
    }
    
    fn get_edge(&self, idx: Index<EdgeIndex>) -> (usize, usize) {
        self.edges[idx.idx]
    }
}
 
fn main() {
    let mut graph = Graph {
        vertices: vec![],
        edges: vec![],
    };
    
    let v1 = graph.add_vertex("A".to_string());
    let v2 = graph.add_vertex("B".to_string());
    let e1 = graph.add_edge(v1, v2);
    
    // Type safety: can't mix up vertex and edge indices
    // graph.get_vertex(e1);  // Won't compile!
}

use std::marker::PhantomData;
 
struct BorrowedBuffer<'a> {
    ptr: *const u8,
    len: usize,
    _marker: PhantomData<&'a [u8]>,
}
 
impl<'a> BorrowedBuffer<'a> {
    fn new(data: &'a [u8]) -> Self {
        BorrowedBuffer {
            ptr: data.as_ptr(),
            len: data.len(),
            _marker: PhantomData,
        }
    }
    
    fn as_slice(&self) -> &'a [u8] {
        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
    }
}
 
fn main() {
    let data = vec![1, 2, 3, 4, 5];
    let buffer = BorrowedBuffer::new(&data);
    
    // Lifetime is tracked correctly
    // buffer cannot outlive data
}

use std::marker::PhantomData;
use std::cell::UnsafeCell;
 
// Invariant cell - necessary for RefCell-like types
struct InvariantCell<T> {
    value: UnsafeCell<T>,
    // This makes InvariantCell invariant in T
    _marker: PhantomData<fn(T) -> T>,
}
 
// Why invariance matters:
fn why_invariance() {
    // If InvariantCell<&'static str> were covariant in &'static str,
    // we could convert InvariantCell<&'static str> to InvariantCell<&'a str>
    // then write a &'a str into it and read it back as &'static str
    // This would be unsound!
    
    // Invariance prevents this conversion
}

use std::marker::PhantomData;
 
// Acts as if it contains T
struct Contains<T> {
    marker: PhantomData<T>,
}
 
// T: Send implies Contains<T>: Send
// T: Sync implies Contains<T>: Sync
 
// Example: pointer wrapper
struct Pointer<T> {
    ptr: *const T,
    _marker: PhantomData<T>,
}
 
// *const T is not Send or Sync by default
// But PhantomData<T> makes Pointer<T> inherit Send/Sync from T
// This is correct because PhantomData<T> means "acts as if it owns T"
 
fn main() {
    fn assert_send<T: Send>() {}
    fn assert_sync<T: Sync>() {}
    
    assert_send::<Contains<i32>>();
    assert_sync::<Contains<i32>>();
    
    // Contains<*const i32> would not be Send/Sync
}

use std::marker::PhantomData;
 
// Pattern 1: Unused type parameter
struct Container<T> {
    data: Vec<u8>,
    _marker: PhantomData<T>,
}
 
// Pattern 2: Type-level state machine
struct StateA;
struct StateB;
struct Machine<S> {
    data: i32,
    _state: PhantomData<S>,
}
 
// Pattern 3: Type-safe handles
struct Handle<T> {
    id: u32,
    _marker: PhantomData<T>,
}
 
// Pattern 4: Lifetime carrying for raw pointers
struct RawSlice<'a, T> {
    ptr: *const T,
    len: usize,
    _marker: PhantomData<&'a T>,
}
 
// Pattern 5: Invariance marker
struct Invariant<T> {
    _marker: PhantomData<fn(T) -> T>,
}
 
// Pattern 6: Ownership assertion
struct Owns<T> {
    _marker: PhantomData<Box<T>>,
}

use std::marker::PhantomData;
use std::cell::Cell;
 
// Force not Send by including !Send type in PhantomData
struct NotSend<T> {
    data: T,
    _marker: PhantomData<*const ()>,  // *const () is !Send
}
 
// Or use Cell which is !Sync
struct NotSync<T> {
    data: T,
    _marker: PhantomData<Cell<()>>,  // Cell is !Sync
}
 
// Use PhantomData to add bounds
struct MustBeSend<T: Send> {
    _marker: PhantomData<T>,
}
 
fn main() {
    fn assert_send<T: Send>() {}
    
    assert_send::<MustBeSend<i32>>();
    // assert_send::<MustBeSend<*const i32>>();  // Won't compile
}