For work-related reasons, I had to recently get up to speed on programming in Haskell.

Before that, I had very little actual experience with the language, clocking probably at less than a thousand lines of working code over a couple of years. Nothing impressive either: some wrapper script here, some experimental rewrite there…

These days, I heard, there are a few resources for learning Haskell that don’t require having a PhD in category theory. They may be quite helpful when your exposure to the functional programming is limited. In my case, however, the one thing that really enabled me to become (somewhat) productive was not even related to Haskell at all.

It was Rust.

In theory, this shouldn’t really make much of a sense. If you compare both languages by putting checkmarks in a feature chart, you won’t find them to have much in common.

Some of the obvious differences include:

predominantly functional vs. mostly imperative

garbage collection vs. explicit memory management

lazy vs. eager evaluation

rich runtime vs. almost no runtime

vs. almost no runtime global vs. localized type inference

indentation vs. braces

two decades (!) vs. barely two years since release

Setting aside syntax, most of those differences are pretty significant.

You probably wouldn’t use Haskell for embedded programming, for instance, both for performance (GC) and memory usage reasons (laziness). Similarly, Rust’s ownership system can be too much of a hassle for high level code that isn’t subject to real time requirements.

But if you look a little deeper, beyond just the surface descriptions of both languages, you can find plenty of concepts they share.

Traits: they are typeclasses, essentially

Take Haskell’s typeclasses, for example — the cornerstone of its rich and expressive type system.

A typeclass is, simply speaking, a list of capabilities: it defines what a type can do. There exist analogs of typeclasses in most programming languages, but they are normally called interfaces or protocols, and remain closely tied to the object-oriented paradigm.

Not so in Haskell.

Or in Rust for that matter, where the equivalent concept exists under the name of traits. What typeclasses and traits have in common is that they’re used for all kinds of polymorphism in their respective languages.

Generics

For example, let’s consider parametrized types, sometimes also referred to as templates (C++) or generics (C#).

In many cases, a generic function or type requires its type arguments to exhibit certain characteristics. In some languages (like the legacy C++), this is checked only implicitly: as long as the template type-checks after its expansion, everything is okay:

template < typename T > T min ( T a , T b ) { return a > b ? b : a ; } struct Foo {}; int main () { min ( 1 , 2 ); // OK min ( Foo (), Foo ()); // ERROR, no operator `>` }

More advanced type systems, however, allow to specify the generic constraints explicitly. This is the case in Rust:

fn min < T : Ord > ( a : T , b : T ) -> T { if a > b { b } else { a } }

as well as in Haskell:

min :: ( Ord a ) => a -> a -> a min a b = if a > b then b else a

In both languages, the notion of a type supporting certain operations (like comparison/ordering) is represented as its own, first-class concept: a trait (Rust) or a typeclass (Haskell). Since the compiler is aware of those constraints, it can verify that the min function is used correctly even before it tries to generate code for a specific substitution of T .

Dynamic dispatch

On the other hand, let’s look at runtime polymorphism: the one that OO languages implement through abstract base classes and virtual methods. It’s the tool of choice if you need a container of objects of different types, which nevertheless all expose the same interface.

To offer it, Rust has trait objects, and they work pretty much exactly like base class pointers/references from Java, C++, or C#.

// Trait definition trait Draw { fn draw ( & self ); } // Data type implementing the trait struct Circle { radius : i32 } impl Draw for Circle { fn draw ( & self ) { /* omitted */ } } // Usage fn draw_all ( objects : & Vec < Box < Draw >> ) { for & obj in objects { obj . draw (); } }

The Haskell analogue is, in turn, based on typeclasses, though the specifics can be a little bit trickier:

{-# LANGUAGE ExistentialQuantification #-} -- Typeclass definition class Draw a where draw :: a -> IO () -- Polymorphic wrapper type data Draw' = forall a . Draw a => Draw' a instance Draw Draw' where draw ( Draw' d ) = draw d -- Data types instantiating ("implementing") the typeclass data Circle = Circle () instance Draw Circle where draw = undefined -- omitted data Square = Square () instance Draw Square where draw = undefined -- omitted -- Usage drawAll :: ( Draw a ) => [ a ] -> IO () drawAll ds = mapM_ draw ds main = do let shapes = [ Draw' Circle () , Draw' Square () ] drawAll shapes

Here, the generic function can use typeclass constraints directly ( (Draw a) => ... ), but creating a container of different object types requires a polymorphic wrapper.

Differences

All those similarities do not mean that Rust traits and Haskell typeclasses are one and the same. There are, in fact, quite a few differences, owing mostly to the fact that Haskell’s type system is more expressive:

Rust lacks higher kinded types, making certain abstractions impossible to encode as traits. It is possible, however, to implement a trait for infinitely many types at once if the impl ementation itself is generic (like here).

When defining a trait in Rust, you can ask implementors to provide some auxiliary, associated types in addition to just methods . A similar mechanism in Haskell is expanded into type families, and requires enabling a GHC extension.

While typeclasses in Haskell can be implemented for multiple types simultaneously via a GHC extension, Rust’s take on this feature is to make traits themselves generic (e.g. trait Foo<T> ). The end result is roughly similar; however, the “main implementing type” (one after for in impl ... for ... ) is still a method receiver ( self ), just like in OO languages.

Rust enforces coherence rules on trait implementations. The topic is actually rather complicated, but the gist is about local (current package) vs. remote (other packages / standard library) traits and types.

Without too much detail, coherence demands that there be a local type or trait somewhere in the impl ... for ... construct. Haskell doesn’t have this limitation, although it is recommended not to take advantage of this.

The M-word

Another area of overlap between Haskell and Rust exists in the data model utilized by those languages. Both are taking heavy advantage of algebraic data types (ADT), including the ability to define both product types (“regular” structs and records) as well as sum types (tagged unions).

Maybe you’d like Some(T) ?

Even more interestingly, code in both languages makes extensive use of the two most basic ADTs:

Option (Rust) or Maybe (Haskell) — for denoting a presence or absence of a value

(Rust) or (Haskell) — for denoting a presence or absence of a value Result (Rust) or Either (Haskell) — for representing the alternative of “correct” and “erroneous” value

These aren’t just simple datatypes. They are deeply interwoven into the basic semantics of both languages, not to mention their standard libraries and community-provided packages.

The Option / Maybe type, for example, is the alternative to nullable references: something that’s been heavily criticized for making programs prone to unexpected NullReferenceException s. The idea behind both of those types is to make actual values impossible to confuse with null s by encoding the potential nullability into the type system:

enum Option < T > { Some ( T ), None }

data Maybe a = Just a | Nothing

Result and Either , on the other hand, can be thought as an extension of this idea. They also represent two possibilities, but the “wrong” one isn’t just None or Nothing — it has some more information associated with it:

enum Result < T , E > { Ok ( T ), Err ( E ) }

data Either e a = Left e | Right a

This dichotomy between the Ok (or Right ) value and the Err or value (or the Left one) makes it a great vehicle for carrying results of functions that can fail.

In Rust, this replaces the traditional error handling mechanisms based on exceptions. In Haskell, the exceptions are present and sometimes necessary, but Either is nevertheless the preferred approach to dealing with errors.

What to do ?

One thing that Haskell does better is composing those fallible functions into bigger chunks of logic.

Relatively recently, Rust has added the ? operator as a replacement for the try! macro. This is now the preferred way of error propagation, allowing for a more concise composition of functions that return Result s:

/// Read an integer from given file. fn int_from_file ( path : & Path ) -> io :: Result < i32 > { let mut file = fs :: File :: open ( path ) ? ; let mut s = String :: new (); file . read_to_string ( & mut s ) ? ; let result = s . parse (). map_err ( | e | io :: Error :: new ( io :: ErrorKind :: InvalidData , e )) ? ; Ok ( result ) }

But Haskell had it for much longer, and it’s something of a hallmark of the language and functional programming in general — even though it looks thoroughly imperative:

intFromFile :: FilePath -> IO Int intFromFile path = do s <- readFile path i <- readIO s return i

If you haven’t seen it before, this is of course a monad — the IO monad, to be precise. While discussing monads in detail is way outside of the scope of this article, we can definitely notice some analogies with Rust. The do notation with <- arrows is evidently similar to how in Rust you’d assign the result of a fallible operation after “unpacking” it with ? .

But of course, there’s plenty of different monads in Haskell: not just IO , but also Either , Maybe , Reader , Writer , Cont , STM , and many others. In Rust (at least as of 1.19), the ? operator only works for Result types, although there is some talk about extending it to Option as well.

Eventually, we may see the language adopt some variant of the do notation, though the motivation for this will most likely come from asynchronous programming with Future s rather than plain Result s. General monads, however, require support for higher kinded types which isn’t coming anytime soon.

A path through Rust?

Now that we’ve discussed those similarities, the obvious question arises.

Is learning Rust worthwhile if your ultimate goal is getting proficient at functional programming in general, or Haskell in particular?

My answer to that is actually pretty straightforward.

If “getting to FP” is your main goal, then Rust will not help you very much. Functional paradigm isn’t the main idea behind the language — its shtick is mostly memory safety, and zero-cost abstractions. While it succeeds somewhat at being “Haskell Lite”, it really strives to be safer C++.

But if, on the other hand, you regard FP mostly as a curiosity that seems to be seeping into your favorite imperative language at an increasing rate, Rust can be a good way to gain familiarity with this peculiar beast.

At the very least, you will learn the functional way of modeling programs, with lots of smart enums/unions and structs but without inheritance.

And the best part is: you will be so busy fighting the borrow checker you won’t even notice when it happens ;-)