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 1: as /u/jkachmar points out on Reddit that there is a
note function in some of alternative Preludes in Haskell (or in
errors package), which is an analog of
ok_or in Rust. Added to the cheatsheet.
Update 2: /u/masklinn says that Haskell
listToMaybe is akin to calling
next on an
maybeToList is an
IntoIterator. I agree with that, since lists in Haskell, being lazy, more or less correspond to Rust iterators. Also, you can iterate over
Option in Rust by calling
Update 4: use
flatten from Iterator to implement
catMaybe, thanks to /u/MysteryManEusine.
Type (Haskell style)
constructor for value
constructor for no value
check if has value
check if has no value
fmap from Functor
apply function to value inside
extract a value, fail if there is none
extract a value or return a given default
(>>=) from Monad
propagate "no value", apply a function to a value, function can return no value too
(<|>) from Alternative
return first value if present or second if not
(>>) from Monad
return first value if none or second if not
takes function and default. Apply function to the value or return default if there is no value
transforms optional value to possible error
filter_map from Iterator
applies filter and map simultaneously
flatten from Iterator
extracts only values from the list, drops no values
join from Monad
squashes two layers of optionality into one
sequence from Traversable
transposes Option and Result layers (or Either and Maybe in Haskell terms)
In Rust, all combinators with
or at the end have a variant with
or_else at the end:
or_else etc. 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:
unwrap which just fails if there is no value
unwrap_or which provides a default for that
unwrap_or_else where this default is calculated by a closure
unwrap_default where default is taken from
Default trait implemented on the type
unwrap_none which fails if the value is not
None and returns nothing
expect which is the same as
unwrap, but takes a custom error message
expect_none which is the same as
unwrap_none but takes a custom error message
Another very useful method in Rust is
as_ref which converts from
Option<&T> which is very handy for pattern matching.
as_mut plays 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
cloned methods for this.
It's possible to mutate optional values in Rust. For that we have
get_or_insert_with methods which allow to insert a new (possibly computed) value into
None or just use the value which was there.
transpose method in Rust is interesting, since it reminds me of
Traversable in Haskell. It basically transpose two layers:
Either in Haskell) and
sequence in Haskell does approximately the same, but in a more generic fashion.
In addition to
or Rust has a method
xor, perhaps just for the completeness. You've probably guessed that it returns
Some if and only if there is only one
Some in its arguments.
Haskell has two functions
maybeToList that convert between trivial lists (with 0 or 1 elements) and
Maybe values. Rust doesn't have those, since lists are not that ubiquitous, but see the Update 2 above.
Rust has more functions to work with
Option than 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.