Fable Rust bindings for Python

[dbrattli]

Hi @ncave, @alexswan10k I've decided to do some investigations using Rust for Python bindings, mostly since I want to learn Rust more than I want to learn Cython. Tried porting this example binding, and could use some suggestions and hints into how the Fable Rust works:

use pyo3::prelude::*;

/// Formats the sum of two numbers as string.
#[pyfunction]
fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
    Ok((a + b).to_string())
}

/// A Python module implemented in Rust.
#[pymodule]
fn string_sum(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
    Ok(())
}

I tried porting it to Fable Rust like this:

module StringSum

open Fable.Core
open Fable.Core.Rust

import "pyo3::prelude::*" ""


[<Erase; Emit("pyo3::prelude::PyErr")>]
type PyErr () =
    do ()

type PyResult<'T> = Result<'T, PyErr>

[<Erase; Emit("pyo3::prelude::Python")>]
type Python () =
    do ()

[<Erase; Emit("pyo3::prelude::PyModule")>]
type PyModule =
    abstract member add_function : obj -> PyResult<unit>

[<Erase; Emit("pyo3::types::PyCFunction")>]
type PyCFunction () =
    do ()

[<Emit("wrap_pyfunction!($0)")>]
let wrap_pyfunction (f: 'T, m: PyModule) : PyResult<PyCFunction> = nativeOnly


[<OuterAttrAttribute("pyfunction")>]
let sum_as_string (a: int) (b: int) : PyResult<string> =
    Ok ((a + b).ToString())

[<OuterAttrAttribute("pymodule")>]
let string_sum (_py: Python, [<ByRef>] m: PyModule) : PyResult<unit> =
    let res = wrap_pyfunction(sum_as_string, m)
    match res with
    | Ok fn -> m.add_function(fn) |> ignore
    | Error err -> ()

    Ok ()

... which generates the following Rust code which have a few problems:

#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(non_upper_case_globals)]
#![allow(unused_parens)]
#![allow(unused_imports)]
#![allow(unused_variables)]
#![allow(unused_attributes)]
pub mod StringSum {
    use super::*;
    use fable_library_rust::Native_::Func1;
    use fable_library_rust::Native_::on_startup;
    use fable_library_rust::String_::string;
    use fable_library_rust::String_::toString;
    use fable_library_rust::Util_::ignore;
    use pyo3::prelude::*;
    on_startup!(());
    #[pyfunction]
    pub fn sum_as_string(a: i32, b: i32)
     -> Result<string, pyo3::prelude::PyErr> {
        Ok(toString(&(a + b)))
    }
    #[pymodule]
    pub fn string_sum(_py: pyo3::prelude::Python, m: &pyo3::prelude::PyModule)
     -> Result<(), pyo3::prelude::PyErr> {
        let res: Result<pyo3::types::PyCFunction, pyo3::prelude::PyErr> =
            wrap_pyfunction!(Func1::new(move |a: i32|
                                            Func1::new({
                                                           let a = a.clone();
                                                           move |b: i32|
                                                               StringSum::sum_as_string(a,
                                                                                        b)
                                                       })));
        match &res {
            Err(res_1_0) => {
                let err: pyo3::prelude::PyErr = res_1_0.clone();
                ()
            }
            Ok(res_0_0) => {
                let r#fn: pyo3::types::PyCFunction = res_0_0.clone();
                ignore(m.add_function(&&r#fn))
            }
        }
        Ok()
    }
}

What do you think? How could I improve this?

Is it possible to write the string_sum in F# or would you just have used Rust instead for the module generation and import the generated sum_as_string? I'm not sure how to handle the ? operator. Is there a way, or should I just match instead? But now I get the trait bound Result<(), PyErr>: Clone is not satisfied

Another thing I could not figure out is how to generate Ok of unit i.e Ok(()) .

I'm sorry for my limited Fable Rust and Rust knowledge 😬 but would be awesome if we one day could e.g use Array.fs, List.fs compiled to Rust as extension modules for Python.

[ncave]

@dbrattli Fable to Rust bindings are unfortunately quite unintuitive and brittle at the moment.

Normally if you have complicated glue code it's easier to have a Rust native module (lib.rs or main.rs) wrapper that then calls the Fable-generated (F# to Rust) library code.

That said, it's definitely possible to do everything in F#, it's just that it's not that intuitive (yet) and you need to work around the issues to make it stick. Basically, the problem usually is mapping the F# generated Rust types to native Rust types.

Here is one version that compiles:

src/lib.fs

module StringSum

open Fable.Core
open Fable.Core.Rust

// To avoid module do bindings, imports are wrapped in a func.
// We have to eventually find a more intuitive way for imports
// that doesn't use module do bindings, but this works for now.
// Native Rust module imports have to contain either '{' or '*'

let imports() =
    import "pyo3::prelude::*" ""
    import "pyo3::types::{PyCFunction}" ""
    ()

[<Erase; Emit("String")>]
type RustString = class end

[<Emit("String::from($0.as_str())")>]
let toRustString (s: string): RustString = nativeOnly

[<Erase; Emit("PyErr")>]
type PyErr = class end

type PyResult<'T> = Result<'T, PyErr>

[<Erase; Emit("Python")>]
type Python = class end

[<Erase; Emit("PyModule")>]
type PyModule = class end

[<Erase; Emit("PyCFunction")>]
type PyCFunction = class end

[<OuterAttr("pyfunction")>]
let sum_as_string (a: int) (b: int) : PyResult<RustString> =
    Ok (toRustString(string (a + b)))

// workaround for emitting function names and reference names
let inline add_function m f =
    emitExpr () (m + ".add_function(wrap_pyfunction!(" + f + ", " + m + ")?)?")

// workaround for emitting unit result wrapped in parenthesis
let inline ok() =
    Ok (emitExpr () "()")

[<OuterAttr("pymodule")>]
let string_sum (_py: Python, [<ByRef>] m: PyModule) : PyResult<unit> =
    add_function (nameof m) (nameof sum_as_string)
    ok()

[dbrattli]

Thank you so much for this @ncave. I understand it can be hard to generate specific Rust binding code like this so really appreciate the help to get started. The plan is to spend some time during the holidays to see if it's easier to use Fable Rust as native bindings for Fable Python instead of investing more in a new language like Cython. This would enable Fable Rust to help the performance of Fable Python and we build and improve on what we already have instead of scaling out with yet another language (cython) which makes things much harder to maintain. I'll start with one of the simpler modules in Fable library and see if I can get all of this to work

[ncave]

@dbrattli Not a problem, please feel free to post any questions or suggestions you might have about fable-library-rust or anything else.