[Show HN] Hsrs：Rust 向け类型安全な Haskell バインディング生成ツール

Haskell から Rust を呼び出すには、型安全で自動的に生成された FFI バインディングをご利用ください。Rust の型や関数にアノテーションを追加し、コードジェネレータを実行することで、メモリ管理、シリアライゼーション、および型のコンバージョンを自動で行うイディオマティックな Haskell コードを手軽に得ることができます。

クイックスタート

1. Rust コードにアノテーションを加える

   #[hsrs::module]
   mod canvas {
       #[hsrs::value_type]
       pub struct Point {
           pub x: i32,
           pub y: i32,
       }
   
       #[hsrs::data_type]
       pub struct Canvas {
           points: Vec<Point>,
       }
   
       impl Canvas {
           #[hsrs::function]
           pub fn new() -> Self { Self { points: vec![] } }
   
           #[hsrs::function]
           pub fn add_point(&mut self, p: Point) { self.points.push(p); }
   
           #[hsrs::function]
           pub fn count(&self) -> u64 { self.points.len() as u64 }
       }
   }
   

2. Haskell バインディングを生成する

   cargo install hsrs-codegen
   hsrs-codegen src/lib.rs -o Bindings.hs
   

3. Haskell 側から利用する

   import Bindings
   
   main :: IO ()
   main = do
       c <- new
       addPoint c (Point 10 20)
       n <- count c
       print n  -- 1
   

   これで完了です。メモリ管理は

   ForeignPtr

   を介して自動的に実行され、複雑な型（例：

   Point

   ）の境界を越えたシリアライゼーションは Borsh を使用して行われます。

セットアップ手順

• Rust 側 — クレートに

  hsrs

  を追加します：

  [lib]
  crate-type = ["lib", "staticlib"]
  
  [dependencies]
  hsrs = "0.1"
  

• Haskell 側 —

  hsrs

  ランタイムパッケージを追加します：

  build-depends:
      hsrs >= 0.1 && < 0.2
  

  これにより、Borsh シリアライゼーションが自動的に依存関係として導入されるため、追加の設定は不要です。

アノテーション可能な項目

#[hsrs::data_type]

#[hsrs::enumeration]

#[hsrs::value_type]

#[hsrs::function]

#[hsrs::module]

Rust の

Result<T, E>

Either E T

Option<T>

Maybe T

Vec<T>

[T]

String

Text

サポートされる型

#[hsrs::enumeration]

#[hsrs::value_type]

プラットフォームに関する注意事項

usize

isize

Word64

Int64

完全な例 列挙型、value type、Result、Option を含む小さな仮想マシン

Rust

#[hsrs::module]
mod quecto_vm {
    #[derive(Debug, PartialEq, Eq)]
    #[hsrs::enumeration]
    pub enum Register { Reg0, Reg1, Count }

    #[derive(Debug, PartialEq, Eq)]
    #[hsrs::value_type]
    pub struct Point { pub x: i32, pub y: i32 }

    #[derive(Debug, PartialEq, Eq)]
    #[hsrs::value_type]
    pub struct VmError { pub code: u32 }

    #[hsrs::data_type]
    pub struct QuectoVm {
        registers: [i64; Register::Count as usize],
        clock: usize,
    }

    impl QuectoVm {
        #[hsrs::function]
        pub fn new() -> Self { /* ... */ }

        #[hsrs::function]
        pub fn store(&mut self, r: Register, v: i64) { /* ... */ }

        #[hsrs::function]
        pub fn snapshot(&self) -> Point { /* ... */ }

        #[hsrs::function]
        pub fn safe_div(&mut self, a: Register, b: Register) -> Result<i64, VmError> { /* ... */ }

        #[hsrs::function]
        pub fn nonzero(&self, r: Register) -> Option<i64> { /* ... */ }
    }
}

生成された Haskell コード

newtype Register = Register Word8
  deriving (Eq, Show, Storable)
  deriving (BorshSize, ToBorsh, FromBorsh) via Word8

pattern Reg0 :: Register
pattern Reg0 = Register 0

data Point = Point
  { pointX :: Int32
  , pointY :: Int32
  } deriving (Generic, Eq, Show)
  deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct Point

data VmError = VmError
  { vmErrorCode :: Word32
  } deriving (Generic, Eq, Show)
  deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct VmError

data QuectoVmRaw
newtype QuectoVm = QuectoVm (ForeignPtr QuectoVmRaw)

new       :: IO QuectoVm
store     :: QuectoVm -> Register -> Int64 -> IO ()
snapshot  :: QuectoVm -> IO Point
safeDiv   :: QuectoVm -> Register -> Register -> IO (Either VmError Int64)
nonzero   :: QuectoVm -> Register -> IO (Maybe Int64)

ライセンス MIT または Apache-2.0