src/test/run-pass/try-operator.rs

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