Result type

Short description: Concept in functional programming

In functional programming, a result type is a monadic type holding a returned value or an error code. They provide an elegant way of handling errors, without resorting to exception handling; when a function that may fail returns a result type, the programmer is forced to consider success or failure paths, before getting access to the expected result; this eliminates the possibility of an erroneous programmer assumption.

## Contents

* 1 Examples
* 1.1 C++
* 1.2 Rust
* 1.3 Vlang
* 2 See also
* 3 References

## Examples

* In C++, it is defined by the standard library as `std::expected<T, E>`.[1]
* In Elm, it is defined by the standard library as `type Result e v = Ok v | Err e`.[2]
* In Haskell, by convention the `Either` type is used for this purpose, which is defined by the standard library as `data Either a b = Left a | Right b`, where `a` is the error type and `b` is the return type.[3]
* In Java, it is not natively in the standard library, but is available from third party libraries. For example, result4j which includes an interface `Result<R, E>` similar to Rust `Result<T, E>`, and vavr includes an interface `Either<L, R>` similar to Haskell `Either a b`. Because Java and Kotlin are cross-compatible, Java can use the `Result` type from Kotlin.
* In Kotlin, it is defined by the standard library as `value class Result<out T>`.[4]
* In OCaml, it is defined by the standard library as `type ('a, 'b) result = Ok of 'a | Error of 'b type`.[5]
* In Python, it is not natively in the standard library, but is available from third party libraries such as returns and result.
* In Rust, it is defined by the standard library as `enum Result<T, E> { Ok(T), Err(E) }`.[6][7]
* In Scala, the standard library also defines an `Either` type,[8] however Scala also has more conventional exception handling.
* In Swift, it is defined by the standard library as `@frozen enum Result<Success, Failure> where Failure : Error`.[9]
* In V, the result type is implemented natively using `!T` as the return type of a function. For example `fn my_function() !string { ... }`. Error Handling in V.

### C++

The `expected<T, E>` class uses `std::unexpected()` to return the type `E`, and can return `T` directly.

import std;

using std::expected;
using std::ifstream;
using std::string;
using std::stringstream;
using std::unexpected;
using std::filesystem::path;

enum class FileError {
MISSING_FILE,
NO_PERMISSION,
// more errors here

expected<string, FileError> loadConfig(const path& p) noexcept {
if (!std::filesystem::exists(p)) {
return unexpected(FileError::MISSING_FILE);

ifstream config{p};
stringstream buffer;
if (!config.is_open()) {
return unexpected(FileError::NO_PERMISSION);

buffer << config.rdbuf();
config.close();
return buffer.str();

int main(int argc, char* argv[]) {
path p{"configs/my_config.txt"};
if (const expected<String, FileError> s = loadConfig(p); s.has_value()) {
std::println("Config contents: {}", s.value());
} else {
switch (s.error) {
case FileError::MISSING_FILE:
std::println("Error: path {} not valid or missing!", p);
break;
case FileError::NO_PERMISSION:
std::println("Error: no permission to read file at path {}!", p);
break;
// additional cases...
default:
std::unreachable();

### Rust

Enums in Rust are tagged unions, which can be unpacked with strong type checking through pattern matching.

const CAT_FOUND: bool = true;

fn main() {
let result: Result<(), String> = pet_cat();
match result {
Ok(_) => println!("Great, we could pet the cat!"),
Err(error) => println!("Oh no, we couldn't pet the cat: {error}")

fn pet_cat() -> Result<(), String> {
if CAT_FOUND {
Ok(())
} else {
Err(String::from("The cat is nowhere to be found!"))

### Vlang

The `Error` type is an interface for `iError`.

const cat_found = true

fn main() {
cat_name := get_pet_cat_name() or {
println("Oh no, we couldn't pet the cat!")
exit(1)

println('Great, we could pet the cat ' + cat_name)

fn get_pet_cat_name() !string {
if cat_found { return 'Max' }
else { return error('the cat is nowhere to be found') }

## See also

* Option type
* Exception handling
* Tagged union
* Return type

## References

1. ↑ "std::expected - cppreference.com". 2023-08-25. https://en.cppreference.com/w/cpp/utility/expected.
2. ↑ "Result · An Introduction to Elm". https://guide.elm-lang.org/error_handling/result.html.
3. ↑ "Data.Either". 2023-09-22. https://hackage.haskell.org/package/base-4.18.1.0/docs/Data-Either.html.
4. ↑ "Result - Kotlin Programming Language". https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-result/.
5. ↑ "Error Handling · OCaml Tutorials". https://ocaml.org/docs/error-handling#using-the-result-type-for-errors.
6. ↑ "std::result - Rust". https://doc.rust-lang.org/std/result/index.html.
7. ↑ "stdlib: Add result module · rust-lang/rust@c1092fb". 2011-10-29. https://github.com/rust-lang/rust/commit/c1092fb6d88efe51e42df3aae2a321cc669e12a0.
8. ↑ "Scala Standard Library 2.13.12 - scala.util.Either". https://www.scala-lang.org/api/current/scala/util/Either.html. Retrieved 2023-10-09.
9. ↑ "Result | Apple Developer Documentation". https://developer.apple.com/documentation/swift/result.

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Result type. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Result_type&oldid=4228528"