use smallvec::{SmallVec, smallvec};
 
fn main() {
    // from_vec: takes ownership of Vec
    let vec = vec![1, 2, 3, 4, 5];
    let smallvec: SmallVec<[i32; 4]> = SmallVec::from_vec(vec);
    // 'vec' is moved, no longer accessible
    
    // from_slice: copies from a borrowed slice
    let slice = &[1, 2, 3, 4, 5];
    let smallvec: SmallVec<[i32; 4]> = SmallVec::from_slice(slice);
    // 'slice' is still valid, elements were copied
    
    println!("from_vec smallvec: {:?}", smallvec);
    println!("slice still valid: {:?}", slice);
}

use smallvec::SmallVec;
 
// Type that is expensive to clone
#[derive(Debug)]
struct ExpensiveToClone {
    id: u32,
    data: Vec<u8>,  // Potentially large data
}
 
// from_vec doesn't require Clone
fn from_vec_example() -> SmallVec<[ExpensiveToClone; 2]> {
    let vec = vec![
        ExpensiveToClone { id: 1, data: vec![1, 2, 3] },
        ExpensiveToClone { id: 2, data: vec![4, 5, 6] },
    ];
    
    // This works even though ExpensiveToClone doesn't implement Clone!
    SmallVec::from_vec(vec)
}
 
// from_slice DOES require Clone
fn from_slice_example() -> SmallVec<[ExpensiveToClone; 2]> {
    let items = [
        ExpensiveToClone { id: 1, data: vec![1, 2, 3] },
        ExpensiveToClone { id: 2, data: vec![4, 5, 6] },
    ];
    
    // This would fail to compile:
    // SmallVec::from_slice(&items)
    // error: the trait `Clone` is not implemented for `ExpensiveToClone`
    
    // If ExpensiveToClone implemented Clone, this would copy both elements
    todo!()
}
 
fn main() {
    let sv = from_vec_example();
    println!("{:?}", sv);
}

use smallvec::SmallVec;
 
fn main() {
    // SmallVec with inline capacity of 4
    // Elements <= 4 are stored inline, > 4 go to heap
    
    // Case 1: Vec fits inline
    let small = vec![1, 2, 3];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_vec(small);
    // Elements moved from Vec's heap to inline storage
    // Vec's heap allocation freed
    println!("Fits inline: {:?}", sv);
    
    // Case 2: Vec exceeds inline capacity
    let large = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_vec(large);
    // SmallVec takes ownership of Vec's heap allocation
    // No copying or reallocation!
    println!("Exceeds inline: {:?}", sv);
    
    // Case 3: from_slice with small data
    let slice = &[1, 2, 3];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_slice(slice);
    // Elements copied into inline storage
    println!("from_slice small: {:?}", sv);
    
    // Case 4: from_slice with large data
    let slice = &[1, 2, 3, 4, 5, 6, 7, 8];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_slice(slice);
    // Elements copied into new heap allocation
    // (if large enough; otherwise inline)
    println!("from_slice large: {:?}", sv);
}

use smallvec::SmallVec;
 
fn allocation_behavior_inline() {
    // Inline capacity = 4
    
    // from_vec with small Vec (capacity <= 4)
    let vec: Vec<i32> = Vec::with_capacity(4);
    let sv: SmallVec<[i32; 4]> = SmallVec::from_vec(vec);
    // Vec's allocation freed
    // SmallVec uses inline storage
    // Result: 1 deallocation (Vec's), inline storage used
    
    // from_slice with small slice
    let slice = &[1, 2, 3, 4];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_slice(slice);
    // No heap allocation needed
    // Elements copied to inline storage
    // Result: 0 allocations, N copies
}
 
fn allocation_behavior_heap() {
    // from_vec with large Vec
    let mut vec: Vec<i32> = Vec::with_capacity(1000);
    vec.extend(0..1000);
    let sv: SmallVec<[i32; 4]> = SmallVec::from_vec(vec);
    // Vec's heap allocation is reused
    // SmallVec points to existing allocation
    // Result: 0 allocations, 0 copies!
    
    // from_slice with large slice
    let slice: &[i32] = &(0..1000).collect::<Vec<_>>()[..];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_slice(slice);
    // New heap allocation required
    // All elements copied
    // Result: 1 allocation, N copies
}

use smallvec::SmallVec;
use std::time::Instant;
 
fn main() {
    const COUNT: usize = 100_000;
    
    // Benchmark: from_vec vs from_slice for large collections
    
    // from_vec: O(1) for heap case, O(n) for inline case
    let start = Instant::now();
    for _ in 0..COUNT {
        let vec: Vec<u64> = (0..100).collect();
        let sv: SmallVec<[u64; 4]> = SmallVec::from_vec(vec);
        std::hint::black_box(sv);
    }
    let from_vec_time = start.elapsed();
    println!("from_vec: {:?}", from_vec_time);
    
    // from_slice: O(n) always (must copy elements)
    let data: Vec<u64> = (0..100).collect();
    let start = Instant::now();
    for _ in 0..COUNT {
        let sv: SmallVec<[u64; 4]> = SmallVec::from_slice(&data);
        std::hint::black_box(sv);
    }
    let from_slice_time = start.elapsed();
    println!("from_slice: {:?}", from_slice_time);
    
    // from_vec is typically faster because:
    // 1. No element copying when Vec exceeds inline capacity
    // 2. Even for inline case, may be faster due to ownership semantics
}

use smallvec::SmallVec;
 
fn main() {
    // When data fits inline, both methods copy, but differently:
    
    // SmallVec<[i32; 8]> - capacity for 8 elements inline
    let data = vec![1, 2, 3, 4, 5];
    
    // from_vec: moves elements from Vec's heap to inline
    let sv1: SmallVec<[i32; 8]> = SmallVec::from_vec(data);
    // Vec's heap allocation freed
    // Elements moved individually into inline storage
    
    let slice = &[1, 2, 3, 4, 5];
    
    // from_slice: copies from slice to inline
    let sv2: SmallVec<[i32; 8]> = SmallVec::from_slice(slice);
    // Elements copied from slice to inline storage
    
    // Both result in inline storage, but:
    // - from_vec frees Vec's allocation
    // - from_slice keeps source slice intact
    
    // For types implementing Copy, the difference is minimal
    // For complex types, from_vec may avoid expensive clones
}

use smallvec::SmallVec;
 
fn main() {
    // When Vec exceeds inline capacity, from_vec reuses allocation
    
    // Vec with capacity 1000 (exceeds inline capacity of 4)
    let vec: Vec<String> = (0..1000)
        .map(|i| format!("string_{}", i))
        .collect();
    
    // Vec has allocated memory on heap
    let vec_capacity = vec.capacity();
    println!("Vec capacity: {}", vec_capacity);
    
    // from_vec takes ownership of this allocation
    let sv: SmallVec<[String; 4]> = SmallVec::from_vec(vec);
    
    // No strings are copied or cloned!
    // The SmallVec uses the same heap allocation
    // This is a pointer transfer, not an element copy
    
    // Compare with from_slice:
    let vec2: Vec<String> = (0..1000)
        .map(|i| format!("string_{}", i))
        .collect();
    let slice: &[String] = &vec2;
    
    // from_slice would clone all 1000 strings
    // let sv2: SmallVec<[String; 4]> = SmallVec::from_slice(slice);
    // This would be expensive!
    
    println!("SmallVec uses heap: {}", !sv.is_inline());
}

use smallvec::SmallVec;
 
// SmallVec is roughly:
// 
// struct SmallVec<[T; N]> {
//     // Inline storage for N elements
//     inline: [MaybeUninit<T>; N],
//     // Or pointer to heap allocation
//     heap_ptr: NonNull<T>,
//     // Current length and capacity info
//     len: usize,
//     // Flag indicating whether using inline or heap
// }
//
// from_vec(Vec<T>):
//   - If Vec capacity <= N: move elements into inline, free Vec's allocation
//   - If Vec capacity > N: take ownership of Vec's RawVec (heap allocation)
//   - No Clone needed because ownership is transferred
//
// from_slice(&[T]) where T: Clone:
//   - Always allocates (inline or heap) and copies all elements
//   - Requires Clone because elements are copied
//   - Source slice remains valid
 
fn main() {
    // Inline capacity = 2
    type MySmallVec = SmallVec<[String; 2]>;
    
    // from_vec with Vec that fits inline
    let small_vec = vec!["a".to_string(), "b".to_string()];
    let sv = MySmallVec::from_vec(small_vec);
    println!("Small inline: is_inline = {}", sv.is_inline());
    
    // from_vec with Vec that needs heap
    let large_vec: Vec<String> = (0..100)
        .map(|i| format!("item_{}", i))
        .collect();
    let sv = MySmallVec::from_vec(large_vec);
    println!("Large heap: is_inline = {}", sv.is_inline());
    
    // from_slice always copies
    let slice_data: Vec<String> = (0..100)
        .map(|i| format!("item_{}", i))
        .collect();
    // Would require cloning 100 strings if we used from_slice
}

use smallvec::SmallVec;
 
fn main() {
    // SmallVec can be converted back to Vec
    
    // Case 1: Inline SmallVec -> Vec
    let sv: SmallVec<[i32; 4]> = smallvec::smallvec![1, 2, 3];
    let vec = sv.into_vec();
    // Allocates new Vec, moves elements from inline
    
    // Case 2: Heap SmallVec -> Vec
    let sv: SmallVec<[i32; 4]> = (0..100).collect();
    let vec = sv.into_vec();
    // If heap capacity is "close" to length, reuses allocation
    // Otherwise allocates new Vec
    
    // Round-trip: Vec -> SmallVec -> Vec
    let original = vec![1, 2, 3, 4, 5];
    let sv: SmallVec<[i32; 4]> = SmallVec::from_vec(original);
    let recovered = sv.into_vec();
    // If original was large enough for heap:
    // - from_vec: takes Vec's allocation
    // - into_vec: returns allocation (same one)
    // Very efficient round-trip!
}

use smallvec::{SmallVec, smallvec};
 
// When a function might return small or large data,
// SmallVec allows optimization for the common small case
 
fn parse_numbers(input: &str) -> SmallVec<[i32; 16]> {
    // Most inputs have <= 16 numbers (inline)
    // Rarely, inputs are larger (heap)
    
    let numbers: Vec<i32> = input
        .split_whitespace()
        .filter_map(|s| s.parse().ok())
        .collect();
    
    // Option 1: from_vec (owns the data)
    SmallVec::from_vec(numbers)
    
    // Option 2: from_slice (if we borrowed the data)
    // Would be: SmallVec::from_slice(&numbers)
    // But that requires Clone and copies elements
}
 
fn parse_numbers_borrowed(input: &str) -> SmallVec<[i32; 16]> {
    // If we don't need to keep a Vec around:
    let numbers: Vec<i32> = input
        .split_whitespace()
        .filter_map(|s| s.parse().ok())
        .collect();
    
    // from_vec is correct here - we own the Vec
    SmallVec::from_vec(numbers)
}
 
fn main() {
    let small = parse_numbers("1 2 3 4 5");
    let large = parse_numbers(&"1 ".repeat(100));
    
    println!("Small inline: {}", small.is_inline());
    println!("Large heap: {}", !large.is_inline());
}

use smallvec::SmallVec;
 
// Integration with APIs that return Vec
fn receive_large_data() -> Vec<u8> {
    // Imagine this comes from network or file
    (0..10000).collect()
}
 
fn process_data() -> SmallVec<[u8; 256]> {
    let vec = receive_large_data();
    
    // from_vec takes ownership without copying
    SmallVec::from_vec(vec)
    
    // If we used from_slice:
    // let sv = SmallVec::from_slice(&vec);
    // - Vec would still be allocated
    // - All 10000 bytes would be copied
    // - Double memory usage temporarily
}
 
// Integration with APIs that provide slices
fn process_borrowed_data(data: &[u8]) -> SmallVec<[u8; 256]> {
    // When data is borrowed, from_slice is appropriate
    SmallVec::from_slice(data)
}
 
fn main() {
    let processed = process_data();
    println!("Processed {} bytes", processed.len());
}

use smallvec::SmallVec;
 
fn main() {
    // Vec with excess capacity
    let mut vec: Vec<i32> = Vec::with_capacity(1000);
    vec.extend(0..100);  // 100 elements, capacity 1000
    
    // from_vec preserves the capacity when using heap
    let sv: SmallVec<[i32; 4]> = SmallVec::from_vec(vec);
    // sv now has capacity 1000 (the Vec's capacity)
    
    // This is important for subsequent pushes
    println!("Capacity after from_vec: {}", sv.capacity());
    
    // from_slice doesn't have capacity info, allocates for exact size
    let slice: &[i32] = &(0..100).collect::<Vec<_>>()[..];
    let sv2: SmallVec<[i32; 4]> = SmallVec::from_slice(slice);
    // Capacity is exactly 100 (no extra)
    
    println!("Capacity from from_slice: {}", sv2.capacity());
}

// Summary of key differences:
 
fn comparison_table() {
    //                    from_vec(Vec)     from_slice(&[T])
    // -------------------------------------------------------
    // Ownership          Takes ownership   Borrows
    // Clone required?    No                Yes
    // Copies elements?   Only if inline    Always
    // Reuses allocation? Yes (if heap)     No (new allocation)
    // Capacity preserved? Yes              No (exact size)
    // Zero-copy?         Yes (heap case)   Never
    // Source valid?      No (moved)        Yes (borrowed)
}