Communication between C# and Haskell

Question

I have this Haskell Code:

module RectangleMover where

data Point = Point Int Int deriving (Show)
movePoint :: Point -> Int -> Int -> Point
movePoint (Point x y) dx dy = Point (x + dx) (y + dy)

data Rectangle = Rectangle { corner :: Point, width :: Int, height :: Int } deriving (Show)
move :: Rectangle -> Int -> Int -> Rectangle
move r@(Rectangle {corner=c}) dx dy = r { corner = movePoint c dx dy }

p = Point 1 2
hsRec = Rectangle p 10 20

The equivalent C# code for this would be:

class Point
{
    private int x;

    private int y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public void Move(int dx, int dy)
    {
        this.x += dx;
        this.y += dy;
    }
}

class Rectangle
{
    private Point point;

    private int width;

    private int height;

    public Rectangle(Point p, int width, int height)
    {
        this.point = p;
        this.width = width;
        this.height = height;
    }

    public void Move(int dx, int dy)
    {
        this.point.Move(dx, dy);
    }
}

Point p = new Point(1,2);
Rectangle csRec = new Rectangle(p, 10, 20);

My question now is how to pass the "instance" hsRec Haskell to C# and the csRec from C# to Haskell. The common way in this case would be to create a DLL from Haskell code with the FFI and call this DLL from C#. Also the other way round, creating a DLL from C# and call this DLL from Haskell.

To export from Haskell here is a simple example with integer:

{-# LANGUAGE ForeignFunctionInterface #-}

module Add () where

import Foreign.C.Types

add :: CInt -> CInt -> CInt
add x y = x + y

foreign export ccall add :: CInt -> CInt -> CInt

But how is it possible to pass more complex types between these languages? In this case passing an object of type rectangle. Is it maybe possible to convert an object to a JSON or XML string and pass it over to the other language?

Answer 1

Your options here are:

• Manually convert all your C# / Haskell structures to/from plain C structures. (High performance, complex to write, hard to debug).

• Manually serialise / deserialise your C# / Haskell structures as JSON / XML / YAML / CSV / whatever. (Lower performance, drastically easier to debug.)

• For every data structure, manually write and expose functions that know how to fetch trivial data out of it. (E.g., if you have a Haskell Map, export functions for fetching one key at a time, in a way trivial enough for C to understand, and then wrap that from the C# side.)

AFAIK, there's no way to "directly" or "automatically" make C# understand the layout of Haskell objects, or vice versa.

Answer 2

The most efficient way is to create a bridge between Haskell and C# using the C FFI. That's going to be a lot of work.

Another way is to use a common serialization protocol like MessagePack. Here's a Haskell library that makes it very easy to communicate with other languages via MessagePack: https://github.com/nh2/call-haskell-from-anything

Obviously this technique has a high "calling" overhead, but it will be much faster than using a REST API and going through a network stack (which of course is another option). As long as the calling overhead is not your bottleneck, then this is a perfectly reasonable method.