Comment on page
Cheatsheet: Option (in Rust) vs Maybe (in Haskell)
Correspondence of common combinators
This is meant to be for people coming from Haskell to Rust or vice versa who want to quickly find the name of corresponding function on optional values. For example, I keep forgetting the names of Rust combinators. Which one I have to use in a particular situation? Is it
unwrap_or_else? I can imagine that other people may experience similar problems, hence the cheatsheet. You can find examples and more detailed description in the official documentation by clicking on function names.
Update 2: /u/masklinn says that Haskell
listToMaybeis akin to calling
IntoIterator. I agree with that, since lists in Haskell, being lazy, more or less correspond to Rust iterators. Also, you can iterate over
Optionin Rust by calling
In Rust, all combinators with
orat the end have a variant with
or_elseat the end:
or_elseetc. Those variants take a closure for the default value and are lazily evaluated. They are recommended when you have a function call returning default value. In Haskell there is no need for this, since it is a lazy language by default.
In Rust there are many different ways for extracting the optional value:
unwrapwhich just fails if there is no value
unwrap_orwhich provides a default for that
unwrap_or_elsewhere this default is calculated by a closure
unwrap_defaultwhere default is taken from
Defaulttrait implemented on the type
unwrap_nonewhich fails if the value is not
Noneand returns nothing
expectwhich is the same as
unwrap, but takes a custom error message
expect_nonewhich is the same as
unwrap_nonebut takes a custom error message
Another very useful method in Rust is
as_refwhich converts from
Option<&T>which is very handy for pattern matching.
as_mutplays a similar role for mutable references.
In Rust there are several methods related to ownership of the value in the
replace, they have no analogs in Haskell that does not have the ownership concept.
In Rust we sometimes want to copy or clone values, it's possible to do so on optional references (
Option<&T>) to get
Option<T>from those by cloning or copying the referenced value. There are
clonedmethods for this.
It's possible to mutate optional values in Rust. For that we have
get_or_insert_withmethods which allow to insert a new (possibly computed) value into
Noneor just use the value which was there.
transposemethod in Rust is interesting, since it reminds me of
Traversablein Haskell. It basically transpose two layers:
Eitherin Haskell) and
sequencein Haskell does approximately the same, but in a more generic fashion.
In addition to
orRust has a method
xor, perhaps just for the completeness. You've probably guessed that it returns
Someif and only if there is only one
Somein its arguments.
Haskell has two functions
maybeToListthat convert between trivial lists (with 0 or 1 elements) and
Maybevalues. Rust doesn't have those, since lists are not that ubiquitous, but see the Update 2 above.
Rust has more functions to work with
Optionthan Haskell because it has to support references, mutability and ownership. On the other hand Haskell outsources some of the combinators to its generic typeclasses:
Monoidetc. so its combinator library seems thinner.