garnet/haskell/exe/Main.hs

module Main (main) where

import Foreign
import Foreign.C
import GarnetRs
import GarnetRs.Safe
import HsBindgen.Runtime.Marshal
import HsBindgen.Runtime.PtrConst

main :: IO ()
main = do
    withCString "Haskell" $ hello . unsafeFromPtr
    alloca \ptr -> do
        writeRaw ptr T{a = CBool 1, b = 42}
        hello_struct (unsafeFromPtr ptr)
    alloca \ptr -> do
        writeRaw ptr (Shape (Shape_Tag 0) (set_shape_body_circle (Circle_Body 3.14)))
        hello_shape (unsafeFromPtr ptr)
    alloca \ptr -> do
        writeRaw ptr (Shape (Shape_Tag 1) (set_shape_body_rectangle (Rectangle_Body 10.0 5.0)))
        hello_shape (unsafeFromPtr ptr)
Initial 2026-02-17 14:57:34 +00:00			`module Main (main) where`

Add more complex data types 2026-02-19 11:11:23 +00:00			`import Foreign`
Expose explicit C interface We drop the tools specifically designed for Haskell and Rust together, in favour of general tools for using each with C. Namely, we use Mozilla's `cbindgen` for generating header files from the Rust source, and Well-Typed's new `hs-bindgen` tool for generating Haskell from those header files. The Rust code here is essentially the result of expanding the old macro, then inlining and renaming internals. The most important thing here is that we're now relying solely on robust well-maintained tools. 2026-02-19 11:08:20 +00:00			`import Foreign.C`
Add more complex data types 2026-02-19 11:11:23 +00:00			`import GarnetRs`
Expose explicit C interface We drop the tools specifically designed for Haskell and Rust together, in favour of general tools for using each with C. Namely, we use Mozilla's `cbindgen` for generating header files from the Rust source, and Well-Typed's new `hs-bindgen` tool for generating Haskell from those header files. The Rust code here is essentially the result of expanding the old macro, then inlining and renaming internals. The most important thing here is that we're now relying solely on robust well-maintained tools. 2026-02-19 11:08:20 +00:00			`import GarnetRs.Safe`
Add more complex data types 2026-02-19 11:11:23 +00:00			`import HsBindgen.Runtime.Marshal`
Expose explicit C interface We drop the tools specifically designed for Haskell and Rust together, in favour of general tools for using each with C. Namely, we use Mozilla's `cbindgen` for generating header files from the Rust source, and Well-Typed's new `hs-bindgen` tool for generating Haskell from those header files. The Rust code here is essentially the result of expanding the old macro, then inlining and renaming internals. The most important thing here is that we're now relying solely on robust well-maintained tools. 2026-02-19 11:08:20 +00:00			`import HsBindgen.Runtime.PtrConst`
Call Rust from Haskell with `cargo-cabal` and `hs-bindgen` See https://sraka.xyz/posts/hs-bindgen-introduction.html. For now, this is a shell-based workflow, rather than using Nix to build everything, i.e. `nix develop` works but `nix build` doesn't. And `cargo build` has to be called manually to create the C library, rather than `cabal` being clever enough to invoke it itself. We ran `cargo cabal init` from the `rust` directory (`nix shell github:yvan-sraka/cargo-cabal`), which generated `hsbindgen.toml` (which we use), and `Setup.lhs` (which just added `extra-lib-dirs`, and with the wrong paths, so we dspecify those statically instead in `garnet.cabal`). We also follow its advice to use `staticlib`. Also, after we ran the first `cargo build` (requiring a `mkdir rust/src` before it would run), we took the generated the Haskell file, and moved the main contents in to `Main.hs` manually. 2026-02-18 15:49:08 +00:00
Initial 2026-02-17 14:57:34 +00:00			`main :: IO ()`
Expose explicit C interface We drop the tools specifically designed for Haskell and Rust together, in favour of general tools for using each with C. Namely, we use Mozilla's `cbindgen` for generating header files from the Rust source, and Well-Typed's new `hs-bindgen` tool for generating Haskell from those header files. The Rust code here is essentially the result of expanding the old macro, then inlining and renaming internals. The most important thing here is that we're now relying solely on robust well-maintained tools. 2026-02-19 11:08:20 +00:00			`main = do`
			`withCString "Haskell" $ hello . unsafeFromPtr`
Add more complex data types 2026-02-19 11:11:23 +00:00			`alloca \ptr -> do`
			`writeRaw ptr T{a = CBool 1, b = 42}`
			`hello_struct (unsafeFromPtr ptr)`
			`alloca \ptr -> do`
			`writeRaw ptr (Shape (Shape_Tag 0) (set_shape_body_circle (Circle_Body 3.14)))`
			`hello_shape (unsafeFromPtr ptr)`
			`alloca \ptr -> do`
			`writeRaw ptr (Shape (Shape_Tag 1) (set_shape_body_rectangle (Rectangle_Body 10.0 5.0)))`
			`hello_shape (unsafeFromPtr ptr)`