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

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