Rustのマクロでインデックスを繰り返し展開するのを避けるにはどうすればいいですか？

Question

このマクロを書く方法はありますか？大規模な配列をあまり冗長な方法で書くことができないように配列のアクセスを拡張しますか？

/// Avoid manually expanding an expression, eg: 
/// 
/// let array = unpack!([some.vec; 3]); 
/// 
/// Expands into: [some.vec[0], some.vec[1], some.vec[2]] 
/// 
/// Supports expanding into different bracket types based on the input args. 

macro_rules! unpack { 
    ([$v_:expr; 2]) => { { let v = $v_; [v[0], v[1]] } }; 
    (($v_:expr; 2)) => { { let v = $v_; (v[0], v[1]) } }; 
    ({$v_:expr; 2}) => { { let v = $v_; {v[0], v[1]} } }; 

    ([$v_:expr; 3]) => { { let v = $v_; [v[0], v[1], v[2]] } }; 
    (($v_:expr; 3)) => { { let v = $v_; (v[0], v[1], v[2]) } }; 
    ({$v_:expr; 3}) => { { let v = $v_; {v[0], v[1], v[2]} } }; 

    ([$v_:expr; 4]) => { { let v = $v_; [v[0], v[1], v[2], v[3]] } }; 
    (($v_:expr; 4)) => { { let v = $v_; (v[0], v[1], v[2], v[3]) } }; 
    ({$v_:expr; 4}) => { { let v = $v_; {v[0], v[1], v[2], v[3]} } }; 
} 

Answer 1

冗長性を減らすために、再帰マクロを作成できます。

macro_rules! unpack { 
    ({$vec:expr; $count:expr}) => { 
     unpack!([$vec; $count]) 
    }; 
    (($vec:expr; $count:expr)) => { 
     unpack!([$vec; $count]) 
    }; 
    ([$vec:expr; $count:expr]) => { 
     $vec[0..$count] 
    }; 
} 

fn main() { 
    let vec = vec![1, 2, 3, 4, 5]; 
    assert_eq!([1, 2], unpack!({vec; 2})); 
    assert_eq!([1, 2, 3], unpack!((vec; 3))); 
    assert_eq!([1, 2, 3, 4], unpack!([vec; 4])); 
} 

すべてのマクロを使用すると、括弧の追加のペアを必要としないので、もし、あなたのマクロは、そのような単純なことができ、()、[]と{}括弧で呼び出すことができます。

macro_rules! unpack { 
    ($vec:expr; $count:expr) => { 
     $vec[0..$count] 
    }; 
} 

fn main() { 
    let vec = vec![1, 2, 3, 4, 5]; 
    assert_eq!([1, 2], unpack!{vec; 2}); 
    assert_eq!([1, 2, 3], unpack!(vec; 3)); 
    assert_eq!([1, 2, 3, 4], unpack![vec; 4]); 
} 

Example錆から本。