src/test/ui/try-operator.rs

   1 // run-pass
   2
   3 #![allow(dead_code)]
   4 // ignore-cloudabi no std::fs
   5
   6 use std::fs::File;
   7 use std::io::{Read, self};
   8 use std::num::ParseIntError;
   9 use std::str::FromStr;
  10
  11 fn on_method() -> Result<i32, ParseIntError> {
  12     Ok("1".parse::<i32>()? + "2".parse::<i32>()?)
  13 }
  14
  15 fn in_chain() -> Result<String, ParseIntError> {
  16     Ok("3".parse::<i32>()?.to_string())
  17 }
  18
  19 fn on_call() -> Result<i32, ParseIntError> {
  20     fn parse<T: FromStr>(s: &str) -> Result<T, T::Err> {
  21         s.parse()
  22     }
  23
  24     Ok(parse("4")?)
  25 }
  26
  27 fn nested() -> Result<i32, ParseIntError> {
  28     Ok("5".parse::<i32>()?.to_string().parse()?)
  29 }
  30
  31 fn on_path() -> Result<i32, ParseIntError> {
  32     let x = "6".parse::<i32>();
  33
  34     Ok(x?)
  35 }
  36
  37 fn on_macro() -> Result<i32, ParseIntError> {
  38     macro_rules! id {
  39         ($e:expr) => { $e }
  40     }
  41
  42     Ok(id!("7".parse::<i32>())?)
  43 }
  44
  45 fn on_parens() -> Result<i32, ParseIntError> {
  46     let x = "8".parse::<i32>();
  47
  48     Ok((x)?)
  49 }
  50
  51 fn on_block() -> Result<i32, ParseIntError> {
  52     let x = "9".parse::<i32>();
  53
  54     Ok({x}?)
  55 }
  56
  57 fn on_field() -> Result<i32, ParseIntError> {
  58     struct Pair<A, B> { a: A, b: B }
  59
  60     let x = Pair { a: "10".parse::<i32>(), b: 0 };
  61
  62     Ok(x.a?)
  63 }
  64
  65 fn on_tuple_field() -> Result<i32, ParseIntError> {
  66     let x = ("11".parse::<i32>(), 0);
  67
  68     Ok(x.0?)
  69 }
  70
  71 fn on_try() -> Result<i32, ParseIntError> {
  72     let x = "12".parse::<i32>().map(|i| i.to_string().parse::<i32>());
  73
  74     Ok(x??)
  75 }
  76
  77 fn on_binary_op() -> Result<i32, ParseIntError> {
  78     let x = 13 - "14".parse::<i32>()?;
  79     let y = "15".parse::<i32>()? - 16;
  80     let z = "17".parse::<i32>()? - "18".parse::<i32>()?;
  81
  82     Ok(x + y + z)
  83 }
  84
  85 fn on_index() -> Result<i32, ParseIntError> {
  86     let x = [19];
  87     let y = "0".parse::<usize>();
  88
  89     Ok(x[y?])
  90 }
  91
  92 fn on_args() -> Result<i32, ParseIntError> {
  93     fn sub(x: i32, y: i32) -> i32 { x - y }
  94
  95     let x = "20".parse();
  96     let y = "21".parse();
  97
  98     Ok(sub(x?, y?))
  99 }
 100
 101 fn on_if() -> Result<i32, ParseIntError> {
 102     Ok(if true {
 103         "22".parse::<i32>()
 104     } else {
 105         "23".parse::<i32>()
 106     }?)
 107 }
 108
 109 fn on_if_let() -> Result<i32, ParseIntError> {
 110     Ok(if let Ok(..) = "24".parse::<i32>() {
 111         "25".parse::<i32>()
 112     } else {
 113         "26".parse::<i32>()
 114     }?)
 115 }
 116
 117 fn on_match() -> Result<i32, ParseIntError> {
 118     Ok(match "27".parse::<i32>() {
 119         Err(..) => "28".parse::<i32>(),
 120         Ok(..) => "29".parse::<i32>(),
 121     }?)
 122 }
 123
 124 fn tight_binding() -> Result<bool, ()> {
 125     fn ok<T>(x: T) -> Result<T, ()> { Ok(x) }
 126
 127     let x = ok(true);
 128     Ok(!x?)
 129 }
 130
 131 // just type check
 132 fn merge_error() -> Result<i32, Error> {
 133     let mut s = String::new();
 134
 135     File::open("foo.txt")?.read_to_string(&mut s)?;
 136
 137     Ok(s.parse::<i32>()? + 1)
 138 }
 139
 140 fn main() {
 141     assert_eq!(Ok(3), on_method());
 142
 143     assert_eq!(Ok("3".to_string()), in_chain());
 144
 145     assert_eq!(Ok(4), on_call());
 146
 147     assert_eq!(Ok(5), nested());
 148
 149     assert_eq!(Ok(6), on_path());
 150
 151     assert_eq!(Ok(7), on_macro());
 152
 153     assert_eq!(Ok(8), on_parens());
 154
 155     assert_eq!(Ok(9), on_block());
 156
 157     assert_eq!(Ok(10), on_field());
 158
 159     assert_eq!(Ok(11), on_tuple_field());
 160
 161     assert_eq!(Ok(12), on_try());
 162
 163     assert_eq!(Ok(-3), on_binary_op());
 164
 165     assert_eq!(Ok(19), on_index());
 166
 167     assert_eq!(Ok(-1), on_args());
 168
 169     assert_eq!(Ok(22), on_if());
 170
 171     assert_eq!(Ok(25), on_if_let());
 172
 173     assert_eq!(Ok(29), on_match());
 174
 175     assert_eq!(Ok(false), tight_binding());
 176 }
 177
 178 enum Error {
 179     Io(io::Error),
 180     Parse(ParseIntError),
 181 }
 182
 183 impl From<io::Error> for Error {
 184     fn from(e: io::Error) -> Error {
 185         Error::Io(e)
 186     }
 187 }
 188
 189 impl From<ParseIntError> for Error {
 190     fn from(e: ParseIntError) -> Error {
 191         Error::Parse(e)
 192     }
 193 }