src/test/ui/array-slice-vec/vec-matching.rs

   1 // run-pass
   2
   3 #![feature(slice_patterns)]
   4
   5 fn a() {
   6     let x = [1];
   7     match x {
   8         [a] => {
   9             assert_eq!(a, 1);
  10         }
  11     }
  12 }
  13
  14 fn b() {
  15     let x = [1, 2, 3];
  16     match x {
  17         [a, b, c @ ..] => {
  18             assert_eq!(a, 1);
  19             assert_eq!(b, 2);
  20             let expected: &[_] = &[3];
  21             assert_eq!(c, expected);
  22         }
  23     }
  24     match x {
  25         [a @ .., b, c] => {
  26             let expected: &[_] = &[1];
  27             assert_eq!(a, expected);
  28             assert_eq!(b, 2);
  29             assert_eq!(c, 3);
  30         }
  31     }
  32     match x {
  33         [a, b @ .., c] => {
  34             assert_eq!(a, 1);
  35             let expected: &[_] = &[2];
  36             assert_eq!(b, expected);
  37             assert_eq!(c, 3);
  38         }
  39     }
  40     match x {
  41         [a, b, c] => {
  42             assert_eq!(a, 1);
  43             assert_eq!(b, 2);
  44             assert_eq!(c, 3);
  45         }
  46     }
  47 }
  48
  49
  50 fn b_slice() {
  51     let x : &[_] = &[1, 2, 3];
  52     match x {
  53         &[a, b, ref c @ ..] => {
  54             assert_eq!(a, 1);
  55             assert_eq!(b, 2);
  56             let expected: &[_] = &[3];
  57             assert_eq!(c, expected);
  58         }
  59         _ => unreachable!()
  60     }
  61     match x {
  62         &[ref a @ .., b, c] => {
  63             let expected: &[_] = &[1];
  64             assert_eq!(a, expected);
  65             assert_eq!(b, 2);
  66             assert_eq!(c, 3);
  67         }
  68         _ => unreachable!()
  69     }
  70     match x {
  71         &[a, ref b @ .., c] => {
  72             assert_eq!(a, 1);
  73             let expected: &[_] = &[2];
  74             assert_eq!(b, expected);
  75             assert_eq!(c, 3);
  76         }
  77         _ => unreachable!()
  78     }
  79     match x {
  80         &[a, b, c] => {
  81             assert_eq!(a, 1);
  82             assert_eq!(b, 2);
  83             assert_eq!(c, 3);
  84         }
  85         _ => unreachable!()
  86     }
  87 }
  88
  89 fn c() {
  90     let x = [1];
  91     match x {
  92         [2, ..] => panic!(),
  93         [..] => ()
  94     }
  95 }
  96
  97 fn d() {
  98     let x = [1, 2, 3];
  99     let branch = match x {
 100         [1, 1, ..] => 0,
 101         [1, 2, 3, ..] => 1,
 102         [1, 2, ..] => 2,
 103         _ => 3
 104     };
 105     assert_eq!(branch, 1);
 106 }
 107
 108 fn e() {
 109     let x: &[isize] = &[1, 2, 3];
 110     let a = match *x {
 111         [1, 2] => 0,
 112         [..] => 1,
 113     };
 114
 115     assert_eq!(a, 1);
 116
 117     let b = match *x {
 118         [2, ..] => 0,
 119         [1, 2, ..] => 1,
 120         [_] => 2,
 121         [..] => 3
 122     };
 123
 124     assert_eq!(b, 1);
 125
 126
 127     let c = match *x {
 128         [_, _, _, _, ..] => 0,
 129         [1, 2, ..] => 1,
 130         [_] => 2,
 131         [..] => 3
 132     };
 133
 134     assert_eq!(c, 1);
 135 }
 136
 137 pub fn main() {
 138     a();
 139     b();
 140     b_slice();
 141     c();
 142     d();
 143     e();
 144 }