Just a pondering.on result<(),T>

[newpavlov]

Everything about Result that pushes you to prefer Ok over Err is artificial in the sense that is based in human expectations and conventions.

It’s a quite strange way to look at things in my opinion. Types are not only about binary representation of valid states, they are also to a large extent about “expectations and conventions”. Wrapper types are the most evident example here, when you see Meter(f32) you start to expect a lot of things from it and will write your code accordingly, even though it’s “just” f32.

Result has a clear semantic meaning and we construct APIs and deal with it according to this meaning. Either while being structurally equivalent to Result has a very different meaning, and I highly doubt that most programmers will think that they are interchangeable.

[skysch]

I don’t think you’re reading what I wrote very clearly, or else I didn’t communicate it properly. The structural similarity of Result<T, E> to Result<E, T> – that is, the binary representation of those types – is not what I’m concerned with.

I’m also not talking about the difference between Result<T, E> and Either<T, E>. I said that Ok and Err are symmetrical; that you could exchange one for the other (everywhere) and produce equivalent programs. You cannot produce equivalent programs by exhcanging Ok with Left, because Result and Either support different operations. (You could replace Left and Right, but that is not a distinguishing feature of Either.)

Meter(f32) you start to expect a lot of things from it and will write your code accordingly, even though it’s “just” f32 .

What Meter(f32) does for us is establish the validity of various operations on the type. It is not isomorphic to f32 in a logical sense, because f32 permits different operations. But this is not true of Result<T, E> and Result<E, T>: the exact same operations are permitted on either type (modulo their names and function composition). The differences between Ok and Err are only that the operations dealing with them are given different syntactical forms, à la the ? operator.

EDIT: I may be conflating some things improperly here, though. If Result defines ? to operate one way, what basis do I have to argue that this isn’t an difference in operation, the same as any other… The ground may not be sturdy here. What I’m trying to express is that an isomorphism between Result<T, E> and Result<E, T> includes transformations for any methods defined on the input, but ? isn’t defined the same way on the other side, so it shouldn’t be an isomorphism then.

[newpavlov]

I said that Ok and Err are symmetrical; that you could exchange one for the other (everywhere) and produce equivalent programs.

My point still stands. While they are symmetrical in a structural sense (i.e. you’ll get an equivalent program after swapping Ok/Err and changing all relevant methods, modulo ?), they have a drastically different meaning for humans. And this difference matters a lot. Remember that we write code to be understood by fellow humans. Thus how types are perceived are equally (or even more) important compared how they are viewed by compiler and represented in machine. And we actively use the difference in meaning between Ok and Err when we write code and design APIs.

If you’ll use Result to communicate two different “happy” results instead of defining domain specific enum, I am more than sure that most of those who will read this code will be confused as hell.

What Meter(f32) does for us is establish the validity of various operations on the type.

No, it’s not only about valid operations. It’s also about in which contexts this type expected to be used. For example the following functions will be really confusing for most of us: measure_duration() -> Meter, get_area() -> Meter, sin(theta: Radian) -> Meter.

BTW this is why I really dislike SystemTime::duration_since method.

[skysch]

Remember that we write code to be understood by fellow humans. Thus how types are perceived are equally (or even more) important compared how they are viewed by compiler and represented in machine.

It’s important to matters of word choice and naming conventions, but it is not important when we’re talking about what information is needed to correctly understand what the code actually does. If decision X is contingent upon fact Y, then it doesn’t matter what words you use for those concepts, you still need knowledge of Y to understand X. Alternatively, the convention that Ok means things are going well doesn’t actually establish that your program is behaving correctly just because it produces and Ok value. Conversely, if I write a parser which happens to return Err, this doesn’t imply that something ‘unhappy’ has happened, only that I need to move on to another parse rule. This is not an error state or an exception, it is normal operation.

It’s also about in which contexts this type expected to be used.

Normally, I would be 100% with you on this matter. But normally, I would only say such a thing when we’re talking about establishing the meanings of words in natural language. In a formal language, the meaning of syntax is established by where it is used, not where it is expected to be used. (Unless we’re talking about the expectations of a compiler or some such – when producing compile errors etc…)

[newpavlov]

Alternatively, the convention that Ok means things are going well doesn’t actually establish that your program is behaving correctly just because it produces and Ok value. Conversely, if I write a parser which happens to return Err , this doesn’t imply that something ‘unhappy’ has happened, only that I need to move on to another parse rule.

I am fine with methods like report_error(err: Err1) -> Result<(), Err2>, but I expect that if function has returned Ok, then associated action has finished without problems, i.e. function has followed a “happy” path, even if this action lies in a catastrophic branch of the program.

As for parser, if it returns Err, then I expect that parsing has failed and I don’t need to look into the parsing code to understand why it happened. “Unhappiness” is local to the function which we execute, e.g. if we first try to parse JSON and if it fails we continue with XML, then failure of parse_json means that our initial assumption about data being JSON was wrong, so parse_json is “unhappy”, but parse_xml could finish “happily”, thus resulting in a “happy” execution of the program, but it does not change the fact that parse_xml was “unhappy”. (damn, these analogies…) Of course we can bubble this “unhappiness”, but it’s optional and has nothing to do with semantics of Result.

[skysch]

“Unhappiness” is local to the function which we execute

That’s what I’ve been trying to say. It’s context dependent. If I write a parser which returns Ok(()) when the parse fails and Err(&str) when it succeeds, then what have I done wrong? All I’ve done is make it easy to propagate parse success rather than parse failure, but Ok and Err have taken on opposite meanings. You could make a parser which ‘digs’ for a match like this. It’s just a different program with different behavior.

[CAD97]

Conversely, if I write a parser which happens to return Err , this doesn’t imply that something ‘unhappy’ has happened, only that I need to move on to another parse rule.

Ok/Err is Success/Failure. A successful parse is Ok. A failed parse is Err.

This is what “happy”/“unhappy” refers to in this case. Result carries this semantic meaning. If it’s not a success/failure case where the Try is accurate, Either (or a domain specific enum) should be used.

[newpavlov]

If I write a parser which returns Ok(()) when the parse fails and Err(&str) when it succeeds, then what have I done wrong?

You wrote a really confusing piece of code. Personally I will be really angry if I’ll stumble upon such code. See my earlier post about programs being written for humans to be understood.

[skysch]

You don’t get to tell me which outputs of my program are ‘success’ or not; I tell you that.

You wrote a really confusing piece of code. Personally I would be really angry if I’ll stumble upon such code. See my earlier post about programs being written for humans to be understood.

If I wrote such a program, I would not call it “parse success” when I return Err, I would call it ‘found’ and be ambiguous. But It may be useful for ? to propagate the condition. I’m not so sure that such a program would be confusing.

[newpavlov]

Please, never write code like this. Using Result just to be able to use ? as a convenient shortcut is… I don’t know… It’s just wrong.

[skysch]

That is what everybody does with ?… that’s why it exists.

[CAD97]

Yes, you tell the user which is success by what is Ok and what is Err. The semantics of Result is such that Err is the failure case.

Result is a type that represents either success ( Ok ) or failure ( Err ).

If I write a parser which returns Ok(()) when the parse fails and Err(&str) when it succeeds, then what have I done wrong?

You have, by your own description, violated what Result represents.

[newpavlov]

No, ? was introduced for specific uses with Result and thus was imbued with a certain meaning. After that it was extended to Option and meaning of ? hasn’t changed much. Now we have (nightly) Try trait, which allows ? to be used with custom types. (note however names of the trait and its methods, again they create a certain expectation for how it should be used)

You could define your custom enum for your parsing library and impl Try for it, so you will be able to use ?, it will be a somewhat questionable approach, but it will be much-much-much less wrong than using Result and significantly less confusing.

[skysch]

There’s definitely some confusion here.

Lets say I write a function which returns Result<i32, u32>. I’m telling you that i32 is Ok and u32 is Err. Good?

This establishes a local convention. You could take what I gave you and rewrite it as a function which returns Result<u32, i32>. Thus there is no inherent ‘errorness’ associated with my Err(u32). It might be quick to propagate a u32 in my code, but now it isn’t in yours. In effect, you disagree with me about what is or is not an error, and that is reflected in your code, by the fact that you swapped the arguments in Result.

I think we’re all in agreement on that. All I’m saying is that, in my code, if I return Ok when an internal parser returns Err, then you certainly won’t care, because you can choose your own interpretation regardless.

[Centril]

Surely naming conventions are not a relevant notion of computational symmetry?

They are relevant for semantic intent and how things are used.

This may as well be a bug.

Bug or not, it is a clear indication of what was thought as important and came first and what was then added later to fix the symmetry.

This impl exists: impl<E, U, T> Product<Result<U, T>> for Result<T, E> where E: Product<U> . Again, whether you use this impl or that one is a matter of convention.

I’m not sure where this impl arises from… https://doc.rust-lang.org/nightly/std/iter/trait.Product.html doesn’t have it.

You could take what I gave you and rewrite it as a function which returns Result<u32, i32> .

That function would likely not read as ergonomically if you were using ? (which I think is a good idea…).

PS: What the Try<Ok = T, Error = E> trait is, is simply a tagless final interpreter of Result<T, E>.

[CAD97]

Yes, because the idea of success/failure is local. Failure of one fn does not imply failure of the parent (thus why ? isn’t implicit).

My point is that there is a difference in what it means to return Result<Q, K> or Result<K, Q>.

[Centril]

A good example of Result<T, T> is https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.binary_search. Here, “found” constitutes success and “not found” constitutes failure.

[skysch]

My point is that there is a difference in what it meand to return Result<Q, K> or Result<K, Q> .

But I can’t know what you think the meaning should be, so it doesn’t matter which one I return. This is key, because it means there isn’t any meaningful difference. You will have to interpret it how you want to either way.

In other words, these two functions will both communicate the same thing:

fn ensure_match(&str, &str) -> Result<&str, i32>;
fn ensure_no_match(&str, &str) -> Result<i32, &str>;

It doesn’t matter which one you have. In either case, you will be determining your own semantics for Result rather than using mine.

(Within those functions, maybe it does matter. But that’s an implementation detail.)

[Centril]

It doesn’t matter which one you have.

I think it matters a great deal if you want to produce understandable APIs; the former seems much more understandable than the latter.

But that’s an implementation detail.

Yeah no… this is not a parenthetical; the whole try { ... } and ? business that is “internal implementation detail” bends heavily a certain way wrt. what APIs are ergonomic to implement.

[skysch]

the former seems much more understandable than the latter.

I don’t buy it. If you want to ensure there’s no match, I don’t see how ensure_match is more understandable. That’s not something that can be established out of context.

the whole try { ... } and ? business that is “internal implementation detail” bends heavily a certain way wrt. what APIs are ergonomic to implement.

And what APIs should be ergonomic to implement?

So I suspect you’re trying to argue that one of these functions will better meet the requirements of some specific class of use-cases. If I’m writing those functions, I should take into account the use-case I’m trying to promote and choose the one that works best there. I believe this just defers the decision: the Result type doesn’t encode any description of the use-case that should be promoted, and if it is convenient for some use, that doesn’t mean it is improper in any other. It can be seen in the code as serendipity if it works well, or a good design if humans intentionally built it that way, but neither of these form a general rule to argue that a given implementation is wrong in the abstract.