tests/ui/try-operator.rs

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