Using Haskell in Rust

After my article on putting Rust in Haskell I
set out on getting Haskell into Rust as part of my test suite for
curryrs which is supposed to
make this much easier. I was having some trouble getting this to work
because Haskell FFI only supports exporting for C. I tried to get this
to work directly with Rust but it didn't work at all. The main issue
being that we need to initialize and end the Haskell runtime when we use
our Haskell functions and closing it when we're done. Linking libraries
also ended up being a problem to overcome to get it done right. It is
possible though! We're going to setup a program from scratch and we're
going to use curryrs to make the types easier between the two.


This articles assumes you have the following installed:

  • rustc - at least 1.12 stable
  • cargo
  • stack
  • GHC 8.0.1
  • gcc
  • make

Setting up the project

First we need to get our Rust code all set up! Initialize a new binary
project like so:

cargo new rushs --bin

Inside the new rushs directory we need to create a new Haskell project.
We'll call it hs2rs and you can initialize it like so:

stack new hs2rs simple-library

Alright let's get all of our Haskell code done first before we put it
into our Rust code.


If you look inside src/Lib.hs in the hs2rs project directory you'll
see that it looks like this:

module Lib
    ( someFunc
    ) where

someFunc :: IO ()
someFunc = putStrLn "someFunc"

We're going to change it so that it looks like this instead:

module Lib where

import Types

triple :: I32 -> I32
triple x = 3 * x

foreign export ccall triple :: I32 -> I32

We're importing the types from curryrs which contain aliases
for all of the types making it easier to write code between both
languages. In this case we're using the I32 type which is i32 in Rust
and Int32 in Haskell. We've also defined a function triple that takes
a value and multiplies it by 3. We've then exported it with the
C calling convention for use in other languages.

Next up we need to import the Haskell FFI headers as part of the library so
we can properly initialize and end the Haskell runtime in our C glue

Open up a file in src called wrapper.c and put this in it:

#include <HsFFI.h>

That's all we need here. Don't compile anything yet since none of this
is truly ready for FFI. We'll need to modify our cabal file next. Open
up hs2rs.cabal

It will look something like this:

name:                hs2rs
synopsis:            Initial project template from stack
description:         Please see
license:             BSD3
license-file:        LICENSE
author:              Author name here
copyright:           2016 Author name here
category:            Web
build-type:          Simple
-- extra-source-files:
cabal-version:       >=1.10

  hs-source-dirs:      src
  exposed-modules:     Lib
  build-depends:       base >= 4.7 && < 5
  default-language:    Haskell2010

source-repository head
  type:     git

We're going to add some options, import some dependencies, and make sure
our c wrapper code is included. Your cabal file will look something like
this when you modify it:

name:                hs2rs
synopsis:            Use Haskell in Rust!
description:         Please see
license:             BSD3
license-file:        LICENSE
author:              Michael Gattozzi
copyright:           2016 Michael Gattozzi
category:            FFI
build-type:          Simple
-- extra-source-files:
cabal-version:       >=1.10

  hs-source-dirs:      src
  exposed-modules:     Lib
  other-extensions:    ForeignFunctionInterface
  ghc-options:         -dynamic -fPIC -shared -lHSrts-ghc8.0.1 -o
  build-depends:       base >= 4.7 && < 5
                     , curryrs
  c-sources:           src/wrapper.c
  default-language:    Haskell2010

source-repository head
  type:     git

The important things to note here are that we need to set
other-extensions to have the ForeignFunctionInterface used for GHC.
Also look at the flags used:

  • -dynamic tells GHC that we want a dynamic library
  • -fPIC is also necessary because of the need for Position Independent Code
  • -lHSrts-ghc8.0.1 is telling GHC to link in the rts library which we
    need for our code to work in other places. It's tied to the version of
    the compiler you use. Just change the last few numbers to the version
    you're using for this to work. However, at the time of writing
    I haven't tested this against other versions.
  • -o is just telling the compiler to stick it in the output file in the main top of the library directory. This is nice for
    reproducible builds in our code rather than digging through
    .stack-work for the library.

Okay one last thing for the code to work. Open up stack.yaml and change
the line extra-deps to the following:

extra-deps: [ "curryrs-" ]

This is so we can import the curryrs library since it's only on Hackage
and not in the current stack LTS.

Now you can compile your code:

stack build

You should see a file show up! We now need to write some C code
to act as our intermediary for Rust and Haskell. Open up a file in this
directory called inter.c and place the following in it:

#include <HsFFI.h>

void init(void) {
  static char *argv[] = { "", 0 }, **argv_ = argv;
  static int argc = 1;

  hs_init(&argc, &argv_);

void fin(void) {

Now run the following:

gcc -shared -o inter.c -fPIC

This creates a shared library that we can use that's linked with using Position Independent Code. We compile it using gcc as a C
compiler so that it can locate all the haskell runtime libraries. inter.c is
just used as a wrapper around hs_init and hs_exit to make it easier to start
and stop the Haskell runtime in Rust. Alright now let's write some Rust!


First up open up Cargo.toml and change it to have a build file and to
add curryrs as a dependency:

name = "rushs"
version = "0.1.0"
authors = ["Michael Gattozzi <>"]
build = ""

curryrs = "^0.1.0"

Next up open up in the top level of the library and put the
following in:

fn main() {

This tells cargo that Rust needs to look inside hs2rs for our and files! When we import them now we don't need
to specify which files need to be linked specifically in the file. Alright
we're finally ready to get our main file all setup. Open up src/ and change
it to look like this:

extern crate curryrs;
use curryrs::types::I32;

extern {
    pub fn init();
    pub fn fin();
    pub fn triple(x: I32) -> I32;

fn main() {
    unsafe { init(); }
    println!("Tripled value: {}", unsafe{triple(50)});
    unsafe { fin(); }

We're first importing the I32 type from curryrs. We then import our
functions we created earlier. This includes our initialization and
exiting functions for the Haskell run time. These are absolutely
necessary or the code won't work. Failure to close the runtime would be
undefined behavior and could hog up resources. Make sure to close it up
when you're done!

Now in our main function we initialize the runtime. We make our call to
triple to make the number 150 then we end the runtime. Alright let's run
the code!

cargo run

You should see "Tripled value: 150" printed out! Congrats you've now
successfully run Haskell inside of Rust!


This is great but what about someone working on building the project?
What about tests? If you try to run the code without having compiled
anything else the whole thing fails. Let's set up a quick easy Makefile
to avoid this problem:

build: hs cargo

	@(cd hs2rs && stack build && gcc -shared -o inter.c -fPIC)

	@cargo build

run: hs
	@cargo run

test: build
	@cargo test

	@cargo doc
	@(cd hs2rs && stack haddock)

	@cargo clean
	@(cd hs2rs && stack clean && rm *.so)

This is a pretty simple file and could easily be expanded to be more
robust. Now you won't need to worry about it not working and can just
get it running with make run! No more worrying about getting all the
flags done right now.

Limitations of this example

This is only the most basic of examples. I'm still unsure of the best
practices of getting data structures passed between the two. If you have
examples of passing them between Rust and Haskell let me know! It would
be great if curryrs could support passing more complex data rather than
just basic primitives.


I've walked you through the basics of using Haskell in Rust. This
includes the setup of your project, a little on how to use curryrs, how
to setup the C files you'll need to interface with Rust and how to
export functions for use in other languages. I've also shown you how to
setup your Rust project, what you would need to include in a build
script, as well as how to call Haskell properly from inside Rust. I
also covered a basic Makefile you can use to make it easier to build the
dependencies for your Rust code.

I'm hoping that examples like this will allow Rust users in the future
to leverage the power Haskell has, such as infinite lists, in their code
or vice versa and allowing Haskell to have a type safe fast language
when speed truly is critical.

If you're interested on bridging that gap as well let me know!

Thanks to Caleb Jones for making some
corrections to this article.