Lib.rs

异构向量

一个就地存储动态大小类型的向量，以牺牲随机访问为代价。元素类型可以是

• 一个特质对象，例如 HeteroSizedVec<dyn Fn() -> u32>
• 一个数组，例如 HeteroSizedVec<[u32]>
• 一个 str，例如 HeteroSizedVec<str>

可靠性

tl;dr: 我不建议在生产环境中使用。

此库针对nightly版本，打开了许多功能门，可能依赖于一些事实上的内存细节，并推动了不安全内存管理的极限。

此外，我快速地创建了它，没有同行评审，测试水平不足。这可能在未来的nightly版本中简单地崩溃，甚至现在可能无法正确工作。

示例

特质对象

extern crate heterovec;
use heterovec::HeteroSizedVec;

fn main() {
    let mut funcs: HeteroSizedVec<dyn Fn(i32) -> i32> =
        HeteroSizedVec::new();
    
    fn adder(x: i32) -> impl Fn(i32) -> i32 {
        move |y| x + y
    }
    
    fn multiplier(x: i32) -> impl Fn(i32) -> i32 {
        move |y| x * y
    }
    
    funcs.push_value(adder(1));       // functions[0]
    funcs.push_value(adder(2));       // functions[1]
    funcs.push_value(adder(3));       // functions[2]
    funcs.push_value(multiplier(10)); // functions[3]
    funcs.push_value(multiplier(16)); // functions[4]
    
    for (i, &(input, output)) in [
        (10, 11),  // 10 + 1  == 11
        (50, 52),  // 50 + 2  == 52
        (0, 3),    // 0 + 3   == 3
        (7, 70),   // 7 * 10  == 70
        (32, 512), // 32 * 16 == 512
    ].iter().enumerate() {
        assert_eq!(funcs[i](input), output);
    }
}

数组

extern crate heterovec;
use heterovec::HeteroSizedVec;

fn main() {
    let mut arrays: HeteroSizedVec<[u32]> = 
        HeteroSizedVec::new();
    
    arrays.push_value([1]);
    arrays.push_value([2, 3]);
    arrays.push_value([4, 5, 6]);
    arrays.push_value([7, 8, 9, 10]);
    
    let elem_5: Vec<u32> = 
        (0_u32..=99).collect::<Vec<u32>>();
    arrays.push(elem_5);
    
    // mutate the elements
    for slice in &mut arrays {
        for number in slice {
            *number += 1;
        }
    }
    
    println!("arrays = {:?}", arrays);
    
    let sums: Vec<u32> = arrays.iter()
        .map(|slice: &[u32]| slice.iter().copied().sum())
        .collect();
        
    assert_eq!(sums, vec![
        2,
        3 + 4,
        5 + 6 + 7,
        8 + 9 + 10 + 11,
        (1..=100).sum()
    ]);
}

字符串

extern crate heterovec;
use heterovec::HeteroSizedVec;

fn main() {
    let mut strs: HeteroSizedVec<str> = 
        HeteroSizedVec::new();
    
    strs.push("hello");
    strs.push("world");
    strs.push(format!("{}+{}={}", 2, 2, 4).as_ref());
 
    // although the elements are not separate `String` 
    // allocations, they are owned.
    //
    // (they are not static string)
    
    {
        let elem: &mut str = &mut strs[1];
        
        // mutate the str in-place
        unsafe { elem.as_bytes_mut()[4] = b'l' };
    }
    
    assert_eq!(&strs[0], "hello");
    assert_eq!(&strs[1], "worll"); 
    assert_eq!(&strs[2], "2+2=4");
}