Manually transpiling Haskell -> Rust

For those who have manually transpiled Haskell code (lots of monads, but not much worry of laziness leading to infinite loop if strict) to Rust code, what lines / day were you able to achieve ?

Is the set of people who have done so successfully nonempty? If so, that's quite a nontrivial feat.
And I'd especially be interested in how to compile monads to native, non-lazy, non-garbage-collected code.

  1. I genui

I genuinely do not know.

Here's the thing. If someone can hand me Rust code that (1) has approximately the same struct / enum / traits, (2) infinite loops due to being strict instead of lazy (3) eats infinite memory due to lack of gc -- I'd consider that extremely valuable .. . like maybe 80% of the work.

Then I can just refactor to great the infinite loops / memory leaks due to Arc/Rc cycles.

Sounds to me like you need to treat the Haskell sources as some kind of requirement specification and develop the Rust code from it's requirements as you would any other project. (That is to say projects created via the waterfall method where we used to have such requirement/high level design specs. Not agile).

Back in the day IBM reckoned a software engineer creates 10 lines of code per working day averaged over the lifetime of a project (including testing, debugging, reworking etc). Sounds low at first sight but every time I checked it has been not far out. I see no reason why your case should be different.

Of course that is lines of delivered Rust code not lines of Haskell "specification". Makes me wonder how much bigger, or smaller, the code might become.

Also, treating the Haskell as a design specification and writing Rust to satisfy it might save you from churning out tons of horrible Rust in an attempt to "transpile" it line by line.