OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Improve naming of tuple getters, and add mutable tuple getter 

Renames the `n*` and `n*_ref` tuple getters to `val*` and `ref*` respectively, and adds `mut*` getters.
This commit is contained in:
Brendan Zabarauskas 2014-02-16 22:19:41 +11:00
parent 2cd7a29013
commit cf0654c47c
5 changed files with 136 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/libcollections/btree.rs
View File

@ -500,15 +500,15 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
let new_outcome = self.clone().rightmost_child.insert(k.clone(), let new_outcome = self.clone().rightmost_child.insert(k.clone(),
v.clone(), v.clone(),
ub.clone()); ub.clone());
new_branch = new_outcome.clone().n0(); new_branch = new_outcome.clone().val0();
outcome = new_outcome.n1(); outcome = new_outcome.val1();
} }
else { else {
let new_outcome = self.clone().elts[index.unwrap()].left.insert(k.clone(), let new_outcome = self.clone().elts[index.unwrap()].left.insert(k.clone(),
v.clone(), v.clone(),
ub.clone()); ub.clone());
new_branch = new_outcome.clone().n0(); new_branch = new_outcome.clone().val0();
outcome = new_outcome.n1(); outcome = new_outcome.val1();
} }
//Check to see whether a branch or a leaf was returned from the //Check to see whether a branch or a leaf was returned from the
//tree traversal. //tree traversal.

4
src/librustdoc/html/render.rs
View File

@ -1379,11 +1379,11 @@ fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
match c.impls.find(&it.id) { match c.impls.find(&it.id) {
Some(v) => { Some(v) => {
let mut non_trait = v.iter().filter(|p| { let mut non_trait = v.iter().filter(|p| {
p.n0_ref().trait_.is_none() p.ref0().trait_.is_none()
}); });
let non_trait = non_trait.to_owned_vec(); let non_trait = non_trait.to_owned_vec();
let mut traits = v.iter().filter(|p| { let mut traits = v.iter().filter(|p| {
p.n0_ref().trait_.is_some() p.ref0().trait_.is_some()
}); });
let traits = traits.to_owned_vec(); let traits = traits.to_owned_vec();

2
src/librustdoc/lib.rs
View File

@ -262,7 +262,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
let mut pm = plugins::PluginManager::new(Path::new(path)); let mut pm = plugins::PluginManager::new(Path::new(path));
for pass in passes.iter() { for pass in passes.iter() {
let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) { let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) {
Some(i) => PASSES[i].n1(), Some(i) => PASSES[i].val1(),
None => { None => {
error!("unknown pass {}, skipping", *pass); error!("unknown pass {}, skipping", *pass);
continue continue

253
src/libstd/tuple.rs
View File

@ -83,36 +83,43 @@ impl<T, U> ImmutableTuple<T, U> for (T, U) {
macro_rules! tuple_impls { macro_rules! tuple_impls {
($( ($(
$Tuple:ident { $Tuple:ident {
$(($get_fn:ident, $get_ref_fn:ident) -> $T:ident { $(($valN:ident, $refN:ident, $mutN:ident) -> $T:ident {
$move_pattern:pat, $ref_pattern:pat => $ret:expr ($($x:ident),+) => $ret:expr
})+ })+
} }
)+) => { )+) => {
$( $(
pub trait $Tuple<$($T),+> { pub trait $Tuple<$($T),+> {
$(fn $get_fn(self) -> $T;)+ $(fn $valN(self) -> $T;)+
$(fn $get_ref_fn<'a>(&'a self) -> &'a $T;)+ $(fn $refN<'a>(&'a self) -> &'a $T;)+
$(fn $mutN<'a>(&'a mut self) -> &'a mut $T;)+
} }
impl<$($T),+> $Tuple<$($T),+> for ($($T,)+) { impl<$($T),+> $Tuple<$($T),+> for ($($T,)+) {
$( $(
#[inline] #[inline]
fn $get_fn(self) -> $T { #[allow(unused_variable)]
let $move_pattern = self; fn $valN(self) -> $T {
$ret let ($($x,)+) = self; $ret
} }
#[inline] #[inline]
fn $get_ref_fn<'a>(&'a self) -> &'a $T { #[allow(unused_variable)]
let $ref_pattern = *self; fn $refN<'a>(&'a self) -> &'a $T {
$ret let ($(ref $x,)+) = *self; $ret
}
#[inline]
#[allow(unused_variable)]
fn $mutN<'a>(&'a mut self) -> &'a mut $T {
let ($(ref mut $x,)+) = *self; $ret
} }
)+ )+
} }
impl<$($T:Clone),+> Clone for ($($T,)+) { impl<$($T:Clone),+> Clone for ($($T,)+) {
fn clone(&self) -> ($($T,)+) { fn clone(&self) -> ($($T,)+) {
($(self.$get_ref_fn().clone(),)+) ($(self.$refN().clone(),)+)
} }
} }
@ -120,11 +127,11 @@ macro_rules! tuple_impls {
impl<$($T:Eq),+> Eq for ($($T,)+) { impl<$($T:Eq),+> Eq for ($($T,)+) {
#[inline] #[inline]
fn eq(&self, other: &($($T,)+)) -> bool { fn eq(&self, other: &($($T,)+)) -> bool {
$(*self.$get_ref_fn() == *other.$get_ref_fn())&&+ $(*self.$refN() == *other.$refN())&&+
} }
#[inline] #[inline]
fn ne(&self, other: &($($T,)+)) -> bool { fn ne(&self, other: &($($T,)+)) -> bool {
$(*self.$get_ref_fn() != *other.$get_ref_fn())||+ $(*self.$refN() != *other.$refN())||+
} }
} }
@ -132,7 +139,7 @@ macro_rules! tuple_impls {
impl<$($T:TotalEq),+> TotalEq for ($($T,)+) { impl<$($T:TotalEq),+> TotalEq for ($($T,)+) {
#[inline] #[inline]
fn equals(&self, other: &($($T,)+)) -> bool { fn equals(&self, other: &($($T,)+)) -> bool {
$(self.$get_ref_fn().equals(other.$get_ref_fn()))&&+ $(self.$refN().equals(other.$refN()))&&+
} }
} }
@ -140,19 +147,19 @@ macro_rules! tuple_impls {
impl<$($T:Ord + Eq),+> Ord for ($($T,)+) { impl<$($T:Ord + Eq),+> Ord for ($($T,)+) {
#[inline] #[inline]
fn lt(&self, other: &($($T,)+)) -> bool { fn lt(&self, other: &($($T,)+)) -> bool {
lexical_ord!(lt, $(self.$get_ref_fn(), other.$get_ref_fn()),+) lexical_ord!(lt, $(self.$refN(), other.$refN()),+)
} }
#[inline] #[inline]
fn le(&self, other: &($($T,)+)) -> bool { fn le(&self, other: &($($T,)+)) -> bool {
lexical_ord!(le, $(self.$get_ref_fn(), other.$get_ref_fn()),+) lexical_ord!(le, $(self.$refN(), other.$refN()),+)
} }
#[inline] #[inline]
fn ge(&self, other: &($($T,)+)) -> bool { fn ge(&self, other: &($($T,)+)) -> bool {
lexical_ord!(ge, $(self.$get_ref_fn(), other.$get_ref_fn()),+) lexical_ord!(ge, $(self.$refN(), other.$refN()),+)
} }
#[inline] #[inline]
fn gt(&self, other: &($($T,)+)) -> bool { fn gt(&self, other: &($($T,)+)) -> bool {
lexical_ord!(gt, $(self.$get_ref_fn(), other.$get_ref_fn()),+) lexical_ord!(gt, $(self.$refN(), other.$refN()),+)
} }
} }
@ -160,7 +167,7 @@ macro_rules! tuple_impls {
impl<$($T:TotalOrd),+> TotalOrd for ($($T,)+) { impl<$($T:TotalOrd),+> TotalOrd for ($($T,)+) {
#[inline] #[inline]
fn cmp(&self, other: &($($T,)+)) -> Ordering { fn cmp(&self, other: &($($T,)+)) -> Ordering {
lexical_cmp!($(self.$get_ref_fn(), other.$get_ref_fn()),+) lexical_cmp!($(self.$refN(), other.$refN()),+)
} }
} }
@ -180,7 +187,7 @@ macro_rules! tuple_impls {
impl<$($T: fmt::Show),+> fmt::Show for ($($T,)+) { impl<$($T: fmt::Show),+> fmt::Show for ($($T,)+) {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write_tuple!(f.buf, $(self.$get_ref_fn()),+) write_tuple!(f.buf, $(self.$refN()),+)
} }
} }
)+ )+
@ -223,106 +230,106 @@ macro_rules! write_tuple {
tuple_impls! { tuple_impls! {
Tuple1 { Tuple1 {
(n0, n0_ref) -> A { (a,), (ref a,) => a } (val0, ref0, mut0) -> A { (a) => a }
} }
Tuple2 { Tuple2 {
(n0, n0_ref) -> A { (a,_), (ref a,_) => a } (val0, ref0, mut0) -> A { (a, b) => a }
(n1, n1_ref) -> B { (_,b), (_,ref b) => b } (val1, ref1, mut1) -> B { (a, b) => b }
} }
Tuple3 { Tuple3 {
(n0, n0_ref) -> A { (a,_,_), (ref a,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c) => a }
(n1, n1_ref) -> B { (_,b,_), (_,ref b,_) => b } (val1, ref1, mut1) -> B { (a, b, c) => b }
(n2, n2_ref) -> C { (_,_,c), (_,_,ref c) => c } (val2, ref2, mut2) -> C { (a, b, c) => c }
} }
Tuple4 { Tuple4 {
(n0, n0_ref) -> A { (a,_,_,_), (ref a,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d) => a }
(n1, n1_ref) -> B { (_,b,_,_), (_,ref b,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d) => b }
(n2, n2_ref) -> C { (_,_,c,_), (_,_,ref c,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d) => c }
(n3, n3_ref) -> D { (_,_,_,d), (_,_,_,ref d) => d } (val3, ref3, mut3) -> D { (a, b, c, d) => d }
} }
Tuple5 { Tuple5 {
(n0, n0_ref) -> A { (a,_,_,_,_), (ref a,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e) => a }
(n1, n1_ref) -> B { (_,b,_,_,_), (_,ref b,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e) => b }
(n2, n2_ref) -> C { (_,_,c,_,_), (_,_,ref c,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e) => c }
(n3, n3_ref) -> D { (_,_,_,d,_), (_,_,_,ref d,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e) => d }
(n4, n4_ref) -> E { (_,_,_,_,e), (_,_,_,_,ref e) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e) => e }
} }
Tuple6 { Tuple6 {
(n0, n0_ref) -> A { (a,_,_,_,_,_), (ref a,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_), (_,ref b,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_), (_,_,ref c,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_), (_,_,_,ref d,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_), (_,_,_,_,ref e,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f), (_,_,_,_,_,ref f) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f) => f }
} }
Tuple7 { Tuple7 {
(n0, n0_ref) -> A { (a,_,_,_,_,_,_), (ref a,_,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f, g) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_,_), (_,ref b,_,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f, g) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_,_), (_,_,ref c,_,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f, g) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_,_), (_,_,_,ref d,_,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f, g) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_,_), (_,_,_,_,ref e,_,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f, g) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f,_), (_,_,_,_,_,ref f,_) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f, g) => f }
(n6, n6_ref) -> G { (_,_,_,_,_,_,g), (_,_,_,_,_,_,ref g) => g } (val6, ref6, mut6) -> G { (a, b, c, d, e, f, g) => g }
} }
Tuple8 { Tuple8 {
(n0, n0_ref) -> A { (a,_,_,_,_,_,_,_), (ref a,_,_,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f, g, h) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_,_,_), (_,ref b,_,_,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f, g, h) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_,_,_), (_,_,ref c,_,_,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f, g, h) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_,_,_), (_,_,_,ref d,_,_,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f, g, h) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_,_,_), (_,_,_,_,ref e,_,_,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f, g, h) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f,_,_), (_,_,_,_,_,ref f,_,_) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f, g, h) => f }
(n6, n6_ref) -> G { (_,_,_,_,_,_,g,_), (_,_,_,_,_,_,ref g,_) => g } (val6, ref6, mut6) -> G { (a, b, c, d, e, f, g, h) => g }
(n7, n7_ref) -> H { (_,_,_,_,_,_,_,h), (_,_,_,_,_,_,_,ref h) => h } (val7, ref7, mut7) -> H { (a, b, c, d, e, f, g, h) => h }
} }
Tuple9 { Tuple9 {
(n0, n0_ref) -> A { (a,_,_,_,_,_,_,_,_), (ref a,_,_,_,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f, g, h, i) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_,_,_,_), (_,ref b,_,_,_,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f, g, h, i) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_,_,_,_), (_,_,ref c,_,_,_,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f, g, h, i) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_,_,_,_), (_,_,_,ref d,_,_,_,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f, g, h, i) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_,_,_,_), (_,_,_,_,ref e,_,_,_,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f, g, h, i) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f,_,_,_), (_,_,_,_,_,ref f,_,_,_) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f, g, h, i) => f }
(n6, n6_ref) -> G { (_,_,_,_,_,_,g,_,_), (_,_,_,_,_,_,ref g,_,_) => g } (val6, ref6, mut6) -> G { (a, b, c, d, e, f, g, h, i) => g }
(n7, n7_ref) -> H { (_,_,_,_,_,_,_,h,_), (_,_,_,_,_,_,_,ref h,_) => h } (val7, ref7, mut7) -> H { (a, b, c, d, e, f, g, h, i) => h }
(n8, n8_ref) -> I { (_,_,_,_,_,_,_,_,i), (_,_,_,_,_,_,_,_,ref i) => i } (val8, ref8, mut8) -> I { (a, b, c, d, e, f, g, h, i) => i }
} }
Tuple10 { Tuple10 {
(n0, n0_ref) -> A { (a,_,_,_,_,_,_,_,_,_), (ref a,_,_,_,_,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f, g, h, i, j) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_,_,_,_,_), (_,ref b,_,_,_,_,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f, g, h, i, j) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_,_,_,_,_), (_,_,ref c,_,_,_,_,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f, g, h, i, j) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_,_,_,_,_), (_,_,_,ref d,_,_,_,_,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f, g, h, i, j) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_,_,_,_,_), (_,_,_,_,ref e,_,_,_,_,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f, g, h, i, j) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f,_,_,_,_), (_,_,_,_,_,ref f,_,_,_,_) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f, g, h, i, j) => f }
(n6, n6_ref) -> G { (_,_,_,_,_,_,g,_,_,_), (_,_,_,_,_,_,ref g,_,_,_) => g } (val6, ref6, mut6) -> G { (a, b, c, d, e, f, g, h, i, j) => g }
(n7, n7_ref) -> H { (_,_,_,_,_,_,_,h,_,_), (_,_,_,_,_,_,_,ref h,_,_) => h } (val7, ref7, mut7) -> H { (a, b, c, d, e, f, g, h, i, j) => h }
(n8, n8_ref) -> I { (_,_,_,_,_,_,_,_,i,_), (_,_,_,_,_,_,_,_,ref i,_) => i } (val8, ref8, mut8) -> I { (a, b, c, d, e, f, g, h, i, j) => i }
(n9, n9_ref) -> J { (_,_,_,_,_,_,_,_,_,j), (_,_,_,_,_,_,_,_,_,ref j) => j } (val9, ref9, mut9) -> J { (a, b, c, d, e, f, g, h, i, j) => j }
} }
Tuple11 { Tuple11 {
(n0, n0_ref) -> A { (a,_,_,_,_,_,_,_,_,_,_), (ref a,_,_,_,_,_,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f, g, h, i, j, k) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_,_,_,_,_,_), (_,ref b,_,_,_,_,_,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f, g, h, i, j, k) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_,_,_,_,_,_), (_,_,ref c,_,_,_,_,_,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f, g, h, i, j, k) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_,_,_,_,_,_), (_,_,_,ref d,_,_,_,_,_,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f, g, h, i, j, k) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_,_,_,_,_,_), (_,_,_,_,ref e,_,_,_,_,_,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f, g, h, i, j, k) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f,_,_,_,_,_), (_,_,_,_,_,ref f,_,_,_,_,_) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f, g, h, i, j, k) => f }
(n6, n6_ref) -> G { (_,_,_,_,_,_,g,_,_,_,_), (_,_,_,_,_,_,ref g,_,_,_,_) => g } (val6, ref6, mut6) -> G { (a, b, c, d, e, f, g, h, i, j, k) => g }
(n7, n7_ref) -> H { (_,_,_,_,_,_,_,h,_,_,_), (_,_,_,_,_,_,_,ref h,_,_,_) => h } (val7, ref7, mut7) -> H { (a, b, c, d, e, f, g, h, i, j, k) => h }
(n8, n8_ref) -> I { (_,_,_,_,_,_,_,_,i,_,_), (_,_,_,_,_,_,_,_,ref i,_,_) => i } (val8, ref8, mut8) -> I { (a, b, c, d, e, f, g, h, i, j, k) => i }
(n9, n9_ref) -> J { (_,_,_,_,_,_,_,_,_,j,_), (_,_,_,_,_,_,_,_,_,ref j,_) => j } (val9, ref9, mut9) -> J { (a, b, c, d, e, f, g, h, i, j, k) => j }
(n10, n10_ref) -> K { (_,_,_,_,_,_,_,_,_,_,k), (_,_,_,_,_,_,_,_,_,_,ref k) => k } (val10, ref10, mut10) -> K { (a, b, c, d, e, f, g, h, i, j, k) => k }
} }
Tuple12 { Tuple12 {
(n0, n0_ref) -> A { (a,_,_,_,_,_,_,_,_,_,_,_), (ref a,_,_,_,_,_,_,_,_,_,_,_) => a } (val0, ref0, mut0) -> A { (a, b, c, d, e, f, g, h, i, j, k, l) => a }
(n1, n1_ref) -> B { (_,b,_,_,_,_,_,_,_,_,_,_), (_,ref b,_,_,_,_,_,_,_,_,_,_) => b } (val1, ref1, mut1) -> B { (a, b, c, d, e, f, g, h, i, j, k, l) => b }
(n2, n2_ref) -> C { (_,_,c,_,_,_,_,_,_,_,_,_), (_,_,ref c,_,_,_,_,_,_,_,_,_) => c } (val2, ref2, mut2) -> C { (a, b, c, d, e, f, g, h, i, j, k, l) => c }
(n3, n3_ref) -> D { (_,_,_,d,_,_,_,_,_,_,_,_), (_,_,_,ref d,_,_,_,_,_,_,_,_) => d } (val3, ref3, mut3) -> D { (a, b, c, d, e, f, g, h, i, j, k, l) => d }
(n4, n4_ref) -> E { (_,_,_,_,e,_,_,_,_,_,_,_), (_,_,_,_,ref e,_,_,_,_,_,_,_) => e } (val4, ref4, mut4) -> E { (a, b, c, d, e, f, g, h, i, j, k, l) => e }
(n5, n5_ref) -> F { (_,_,_,_,_,f,_,_,_,_,_,_), (_,_,_,_,_,ref f,_,_,_,_,_,_) => f } (val5, ref5, mut5) -> F { (a, b, c, d, e, f, g, h, i, j, k, l) => f }
(n6, n6_ref) -> G { (_,_,_,_,_,_,g,_,_,_,_,_), (_,_,_,_,_,_,ref g,_,_,_,_,_) => g } (val6, ref6, mut6) -> G { (a, b, c, d, e, f, g, h, i, j, k, l) => g }
(n7, n7_ref) -> H { (_,_,_,_,_,_,_,h,_,_,_,_), (_,_,_,_,_,_,_,ref h,_,_,_,_) => h } (val7, ref7, mut7) -> H { (a, b, c, d, e, f, g, h, i, j, k, l) => h }
(n8, n8_ref) -> I { (_,_,_,_,_,_,_,_,i,_,_,_), (_,_,_,_,_,_,_,_,ref i,_,_,_) => i } (val8, ref8, mut8) -> I { (a, b, c, d, e, f, g, h, i, j, k, l) => i }
(n9, n9_ref) -> J { (_,_,_,_,_,_,_,_,_,j,_,_), (_,_,_,_,_,_,_,_,_,ref j,_,_) => j } (val9, ref9, mut9) -> J { (a, b, c, d, e, f, g, h, i, j, k, l) => j }
(n10, n10_ref) -> K { (_,_,_,_,_,_,_,_,_,_,k,_), (_,_,_,_,_,_,_,_,_,_,ref k,_) => k } (val10, ref10, mut10) -> K { (a, b, c, d, e, f, g, h, i, j, k, l) => k }
(n11, n11_ref) -> L { (_,_,_,_,_,_,_,_,_,_,_,l), (_,_,_,_,_,_,_,_,_,_,_,ref l) => l } (val11, ref11, mut11) -> L { (a, b, c, d, e, f, g, h, i, j, k, l) => l }
} }
} }
@ -355,33 +362,29 @@ mod tests {
} }
#[test] #[test]
fn test_n_tuple() { fn test_getters() {
let t = (0u8, 1u16, 2u32, 3u64, 4u, 5i8, 6i16, 7i32, 8i64, 9i, 10f32, 11f64); macro_rules! test_getter(
assert_eq!(t.n0(), 0u8); ($x:expr, $valN:ident, $refN:ident, $mutN:ident,
assert_eq!(t.n1(), 1u16); $init:expr, $incr:expr, $result:expr) => ({
assert_eq!(t.n2(), 2u32); assert_eq!($x.$valN(), $init);
assert_eq!(t.n3(), 3u64); assert_eq!(*$x.$refN(), $init);
assert_eq!(t.n4(), 4u); *$x.$mutN() += $incr;
assert_eq!(t.n5(), 5i8); assert_eq!(*$x.$refN(), $result);
assert_eq!(t.n6(), 6i16); })
assert_eq!(t.n7(), 7i32); )
assert_eq!(t.n8(), 8i64); let mut x = (0u8, 1u16, 2u32, 3u64, 4u, 5i8, 6i16, 7i32, 8i64, 9i, 10f32, 11f64);
assert_eq!(t.n9(), 9i); test_getter!(x, val0, ref0, mut0, 0, 1, 1);
assert_eq!(t.n10(), 10f32); test_getter!(x, val1, ref1, mut1, 1, 1, 2);
assert_eq!(t.n11(), 11f64); test_getter!(x, val2, ref2, mut2, 2, 1, 3);
test_getter!(x, val3, ref3, mut3, 3, 1, 4);
assert_eq!(t.n0_ref(), &0u8); test_getter!(x, val4, ref4, mut4, 4, 1, 5);
assert_eq!(t.n1_ref(), &1u16); test_getter!(x, val5, ref5, mut5, 5, 1, 6);
assert_eq!(t.n2_ref(), &2u32); test_getter!(x, val6, ref6, mut6, 6, 1, 7);
assert_eq!(t.n3_ref(), &3u64); test_getter!(x, val7, ref7, mut7, 7, 1, 8);
assert_eq!(t.n4_ref(), &4u); test_getter!(x, val8, ref8, mut8, 8, 1, 9);
assert_eq!(t.n5_ref(), &5i8); test_getter!(x, val9, ref9, mut9, 9, 1, 10);
assert_eq!(t.n6_ref(), &6i16); test_getter!(x, val10, ref10, mut10, 10.0, 1.0, 11.0);
assert_eq!(t.n7_ref(), &7i32); test_getter!(x, val11, ref11, mut11, 11.0, 1.0, 12.0);
assert_eq!(t.n8_ref(), &8i64);
assert_eq!(t.n9_ref(), &9i);
assert_eq!(t.n10_ref(), &10f32);
assert_eq!(t.n11_ref(), &11f64);
} }
#[test] #[test]

2
src/test/bench/shootout-fasta.rs
View File

@ -51,7 +51,7 @@ impl<'a> Iterator<u8> for AAGen<'a> {
fn next(&mut self) -> Option<u8> { fn next(&mut self) -> Option<u8> {
let r = self.rng.gen(); let r = self.rng.gen();
self.data.iter() self.data.iter()
.skip_while(|pc| pc.n0() < r) .skip_while(|pc| pc.val0() < r)
.map(|&(_, c)| c) .map(|&(_, c)| c)
.next() .next()
} }