Show HN: Hsrs – Type-Safe Haskell Bindings Generator for Rust

hckrnws

Show HN: Hsrs – Type-Safe Haskell Bindings Generator for Rust

by suis_siva

Hey everyone! I've been working on hsrs, a type-safe Haskell Bindings Generator for Rust.

I couldn't really find any bindings generator that would create type-safe, rich bindings for Haskell from Rust. Naturally, both languages have rich type systems, so I was amazed that no awesome bindings generator already existed, hence I decided to write my own. hsrs feels very similar to pyo3 and napi-rs, and if you've used those, hsrs will feel right at home.

What's unique about hsrs as opposed to hs-bindgen is that it has type-safe bindings for rich types, like Result, Maybe, etc. while also generating Haskell bindings. The repo contains a minimal example, and more details are available in the haskell discourse: https://discourse.haskell.org/t/ann-hsrs-ergonomic-haskell-b...

_flux
14d
It would be so nice if these "well typed languages" would be able to interact better with each other. Alas, the GC will probably cause some friction, e.g. the ocaml-rs package makes this pretty visible: https://github.com/zshipko/ocaml-rs/blob/master/examples/rus... . (I have not used either of these projects.)
Maybe the GC would be less of a problem if we didn't want to have the best possible performance as well.
1. suis_siva • OP
  04d
  Oh wow, that does seem quite painful. That crate reminds me of how JSC' internal bindings work:
```cpp JSC_DEFINE_HOST_FUNCTION(jsMyFunction, (JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame)) { JSC::VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); ... ```
kind of the same thing, seems like -- passing data around to be managed by the GC.
yccs27
24d
It's great that this allows passing Rust structs both as ForeignPtr and as native records with marshalling!
Some questions/ideas:
- Is there a way to generate #[hsrs::data_type] bindings for Rust library types, or do you need to create custom wrapper types for them?
- It seems like all #[hsrs::function]s are translated to return IO (since Rust functions can do arbitrary side effects). It would be great if you could (unsafely) mark functions as pure, to get pure Haskell functions without having to wrap them in unsafePerformIO.
- Both Haskell and Rust have HM type systems, so I wonder if you could also translate type classes from Rust to Haskell.
1. suis_siva • OP
  14d
Yatsui
02d
Nice work. One thing I didn't see covered: what happens when a #[hsrs::function] panics? Unwinding across the FFI boundary into the Haskell RTS is UB, so I assume there's a catch_unwind somewhere converting it into a Haskell exception, or do panics just abort the process?
rienbdj
24d
Really cool nice job!
With more and more ecosystem libraries being written in Rust (and a Python wrapper) could this be a way to expand the Haskell ecosystem?
1. suis_siva • OP
  04d
  Maybe!