10 ms·

I have no idea what that ? operator does from the summary or staring at the usage example... Was more boilerplate necessary in the example before?

by drewm1980 9y ago

drewm1980 9y ago
Ok so I guess it's a trinary operator with two arguments combined that is able to use Option and Result for the test... I hope autoformatters keep stuff like that on one line!
- GolDDranks 9y ago
  It's an error handling operator that does an early exit in case of None and unwraps the value in case of Some. It used to work only with Result: early exit when Err, unwrapping the value when Ok.
- Manishearth 9y ago
  Nah, in that example there should be a `return` before the `None` -- because it's the only block in the function it doesn't matter. But it's not a ternary operator, it's unary. let val = foo.bar()?; will call `bar()`, return if it is None, and if it is `Some(foo)`, set `val` to `foo`.
viraptor 9y ago
It skips a block you'd need otherwise. Without it, you'd have to do something like: fn try_option_some() -> Option<u8> { if let val = Some(1) { Some(val) } else { None } } It's an early exit if the expression before is None/Error
- Sharlin 9y ago
  There should really be a more real-world example, the current code (and your alternative version) is just redundant and equivalent to fn try_option_some() -> Option<u8> { Some(1) }
  - lower 9y ago
    Suppose you have two functions fn f() -> Result<A, E> fn g() -> Result<B, E> Then you can write fn h() -> Result<(A,B), E> { let x = f()?; let y = g()?; Ok((x, y)) } rather than having to do something like fn h() -> Result<(A,B), E> { match f() { Ok(x) => { match g() { Ok(y) => Ok((x,y)), Err(e) => Err(e) } }, Err(e) => Err(e), } } (written from memory, please excuse syntax errors) What's new is that this also works with Option<A> now.
    - zZorgz 9y ago
      As others mentioned, it looks equivalent to using the try! macro (which I'm not sure this is supposed to replace?) Another sane alternative here is using and_then, map, etc. Writing from memory too: fn h() -> Result<(A, B), E> { f().and_then(|x| g().map(|y| (x, y))) } ..which seems to be a different style of control flow to choose from. On one hand, I suppose one may avoid using and_then with code dealing with side effects. On another hand, ? seems restricted to being used inside functions that have to return a a single type (like Result) they operate on.
      - steveklabnik 9y ago
        ? is explicitly a replacement for try!, yes. > functions that have to return a single type Well, all functions have to return a single type, though that type may be a composite type, like a tuple. Less pedantically, `?` lets you (well, will let you) unwrap values and convert their error cases between each other. So once the next round of stabilization happens, if you have a function that returns Results, you can mix ? on Options and Results in the body, and vice versa. And it can be extended for other types too. Basically, it's an early return "protocol" if you will.
        zZorgz 9y ago
        By single type, I meant to hint not being able to mix ? on Options and Results in the body, but good to know that's soon possible! Though you still can't, eg, use `?` in main()
- masklinn 9y ago
  Technically it also applies a conversion operator to the "error" value (a no-op for the Option -> Option case, but it can be otherwise for Option -> Result or Result<T, E> -> Result<T, F>
- Manishearth 9y ago
  Your example is confusing, too; you've removed the code after the try? so it's not equivalent to the example in the blog, and because it's a single thing there's no early return anymore, thoroughly obfuscating what it is that try did :|
  - irishsultan 9y ago
    Unless I'm missing something it's exactly equivalent (and likely to compile to the same code), after all both check whether there is a value to extract and immediately return None if there isn't, both return Some(val) if there is a value to extract. If you added extra code to manipulate things then that single if would still be enough, just place everything that happens after the extraction inside the success branch of the if statement.
    - Manishearth 9y ago
      You are missing something, it won't compile at all. You're missing a Some(val) at the end. Now you could remove the `if let val` as well to make it compile, but then that obfuscates what the ? operator was doing there.
      - irishsultan 9y ago
        The error seems to be that `if let val = Some(1)` should be `if let Some(val) = Some(1)` (i.e. the pattern match should have extracted val, which is what the ? operator does as well). I think it would have been much clearer to have 1 function which took a parameter of type Option<u8>, then did something with it after extracting with ?, then call it twice, once with Some(1), once with None. In addition I'd probably do something with val (e.g. add 1). And to prevent easy conversion to the if statement you could make the early return explicit by doing the extraction somewhere in a loop (so that you can't get at it with nested if statements).
        Manishearth 9y ago
        No, that, _and_ that if let ... {} doesn't evaluate to anything; your function doesn't evaluate to anything even though it has a stated return type of Option. I mean, this isn't hard to check, try compiling it. I was saying it's misleading not only because it's wrong, but also because even if something is equivalent if you're trying to show how a feature works you want equivalent code that cleanly maps to the original; and isn't further reduced.
cesarb 9y ago
The ? operator used to be the try! macro: https://doc.rust-lang.org/book/first-edition/error-handling.html#the-try-macro https://doc.rust-lang.org/book/first-edition/error-handling.... It's used for shortcut error handling: when for instance you receive an error result from opening a file, you usually want to also return with an error. It was used so often that the ? operator was introduced as a shortcut. Now the operator is being extended to Option<T>, which works similar to Result<T, ()>.
wscott 9y ago
"About a year ago, in Rust 1.13, we introduced the ? operator" And that includes a link to the 1.13 announcement with a detailed explanation. https://blog.rust-lang.org/2016/11/10/Rust-1.13.html https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
masklinn 9y ago
It's a shortcut for "early-returning" in error cases > Was more boilerplate necessary in the example before? Somewhat yes, the original use case is Result types (and the try! macro): let v = func()?; expands to let v = match func() { Ok(v) => v, Err(e) => return Err(From::from(e)) }; that is it "unwraps" a successful result, and barring one it directly returns from the current function (having possibly converted the error). Before 1.22, doing that with an Option would be: let v = match func() { Some(v) => v, None => return None }; or let v = if let Some(v) { v } else { return None }; after 1.22, this becomes let v = func()?; as well. edit: note that this is quite different from the behaviour of the ? operator in languages like C# or Swift where it compounds into "null-safe" operators, the most famous being the null-safe navigation operator "?."[0], these are closer to the monadic bind, which in Rust is called "and_then". [0] https://en.wikipedia.org/wiki/Safe_navigation_operator https://en.wikipedia.org/wiki/Safe_navigation_operator

I have no idea what that ? operator does from the summary or staring at the usage example... Was more boilerplate necessary in the example before?

drewm1980 9y ago

Ok so I guess it's a trinary operator with two arguments combined that is able to use Option and Result for the test... I hope autoformatters keep stuff like that on one line!

GolDDranks 9y ago
It's an error handling operator that does an early exit in case of None and unwraps the value in case of Some. It used to work only with Result: early exit when Err, unwrapping the value when Ok.
Manishearth 9y ago
Nah, in that example there should be a `return` before the `None` -- because it's the only block in the function it doesn't matter. But it's not a ternary operator, it's unary. let val = foo.bar()?; will call `bar()`, return if it is None, and if it is `Some(foo)`, set `val` to `foo`.

viraptor 9y ago

It skips a block you'd need otherwise. Without it, you'd have to do something like: fn try_option_some() -> Option<u8> { if let val = Some(1) { Some(val) } else { None } } It's an early exit if the expression before is None/Error

Sharlin 9y ago
There should really be a more real-world example, the current code (and your alternative version) is just redundant and equivalent to fn try_option_some() -> Option<u8> { Some(1) }
- lower 9y ago
  Suppose you have two functions fn f() -> Result<A, E> fn g() -> Result<B, E> Then you can write fn h() -> Result<(A,B), E> { let x = f()?; let y = g()?; Ok((x, y)) } rather than having to do something like fn h() -> Result<(A,B), E> { match f() { Ok(x) => { match g() { Ok(y) => Ok((x,y)), Err(e) => Err(e) } }, Err(e) => Err(e), } } (written from memory, please excuse syntax errors) What's new is that this also works with Option<A> now.
  - zZorgz 9y ago
    As others mentioned, it looks equivalent to using the try! macro (which I'm not sure this is supposed to replace?) Another sane alternative here is using and_then, map, etc. Writing from memory too: fn h() -> Result<(A, B), E> { f().and_then(|x| g().map(|y| (x, y))) } ..which seems to be a different style of control flow to choose from. On one hand, I suppose one may avoid using and_then with code dealing with side effects. On another hand, ? seems restricted to being used inside functions that have to return a a single type (like Result) they operate on.
    - steveklabnik 9y ago
      ? is explicitly a replacement for try!, yes. > functions that have to return a single type Well, all functions have to return a single type, though that type may be a composite type, like a tuple. Less pedantically, `?` lets you (well, will let you) unwrap values and convert their error cases between each other. So once the next round of stabilization happens, if you have a function that returns Results, you can mix ? on Options and Results in the body, and vice versa. And it can be extended for other types too. Basically, it's an early return "protocol" if you will.
      - zZorgz 9y ago
        By single type, I meant to hint not being able to mix ? on Options and Results in the body, but good to know that's soon possible! Though you still can't, eg, use `?` in main()
masklinn 9y ago
Technically it also applies a conversion operator to the "error" value (a no-op for the Option -> Option case, but it can be otherwise for Option -> Result or Result<T, E> -> Result<T, F>
Manishearth 9y ago
Your example is confusing, too; you've removed the code after the try? so it's not equivalent to the example in the blog, and because it's a single thing there's no early return anymore, thoroughly obfuscating what it is that try did :|
- irishsultan 9y ago
  Unless I'm missing something it's exactly equivalent (and likely to compile to the same code), after all both check whether there is a value to extract and immediately return None if there isn't, both return Some(val) if there is a value to extract. If you added extra code to manipulate things then that single if would still be enough, just place everything that happens after the extraction inside the success branch of the if statement.
  - Manishearth 9y ago
    You are missing something, it won't compile at all. You're missing a Some(val) at the end. Now you could remove the `if let val` as well to make it compile, but then that obfuscates what the ? operator was doing there.
    - irishsultan 9y ago
      The error seems to be that `if let val = Some(1)` should be `if let Some(val) = Some(1)` (i.e. the pattern match should have extracted val, which is what the ? operator does as well). I think it would have been much clearer to have 1 function which took a parameter of type Option<u8>, then did something with it after extracting with ?, then call it twice, once with Some(1), once with None. In addition I'd probably do something with val (e.g. add 1). And to prevent easy conversion to the if statement you could make the early return explicit by doing the extraction somewhere in a loop (so that you can't get at it with nested if statements).
      - Manishearth 9y ago
        No, that, _and_ that if let ... {} doesn't evaluate to anything; your function doesn't evaluate to anything even though it has a stated return type of Option. I mean, this isn't hard to check, try compiling it. I was saying it's misleading not only because it's wrong, but also because even if something is equivalent if you're trying to show how a feature works you want equivalent code that cleanly maps to the original; and isn't further reduced.

cesarb 9y ago

The ? operator used to be the try! macro: https://doc.rust-lang.org/book/first-edition/error-handling.html#the-try-macro https://doc.rust-lang.org/book/first-edition/error-handling.... It's used for shortcut error handling: when for instance you receive an error result from opening a file, you usually want to also return with an error. It was used so often that the ? operator was introduced as a shortcut. Now the operator is being extended to Option<T>, which works similar to Result<T, ()>.

wscott 9y ago

"About a year ago, in Rust 1.13, we introduced the ? operator" And that includes a link to the 1.13 announcement with a detailed explanation. https://blog.rust-lang.org/2016/11/10/Rust-1.13.html https://blog.rust-lang.org/2016/11/10/Rust-1.13.html

masklinn 9y ago

It's a shortcut for "early-returning" in error cases > Was more boilerplate necessary in the example before? Somewhat yes, the original use case is Result types (and the try! macro): let v = func()?; expands to let v = match func() { Ok(v) => v, Err(e) => return Err(From::from(e)) }; that is it "unwraps" a successful result, and barring one it directly returns from the current function (having possibly converted the error). Before 1.22, doing that with an Option would be: let v = match func() { Some(v) => v, None => return None }; or let v = if let Some(v) { v } else { return None }; after 1.22, this becomes let v = func()?; as well. edit: note that this is quite different from the behaviour of the ? operator in languages like C# or Swift where it compounds into "null-safe" operators, the most famous being the null-safe navigation operator "?."[0], these are closer to the monadic bind, which in Rust is called "and_then". [0] https://en.wikipedia.org/wiki/Safe_navigation_operator https://en.wikipedia.org/wiki/Safe_navigation_operator