Does interoptopus work with generics

[mercurial-moon]

Hi I'm trying to use interoptopus for this library https://github.com/lukaslueg/railroad which makes heavy use of generics.

I've done some research and found that Rust doesn't allow generic functions to be exported.

#[no_mangle] is not allowed on generic functions.

Is it possible to use interoptopus on generic functions using some workarounds.
My end goal is to use that rust library in C#/.NET on windows.

[ralfbiedert]

This folder here basically shows what's possible. Actual functions can't be generic (which is a fundamental limitation of any C-like FFI invocation). Types can be generic, if they're specialized for a specific function. Have a look at the functions.rs and types.rs files.

[mercurial-moon]

Hi thanks for the info,

take for example this snippet of code from that lib

#[derive(Debug, Clone)]
pub struct Link<N> {
    inner: N,
    uri: String,
    target: Option<LinkTarget>,
    attributes: HashMap<String, String>,
}

impl<N> Link<N> {
    pub fn new(inner: N, uri: String) -> Self {
        let mut l = Self {
            inner,
            uri,
            target: None,
            attributes: HashMap::default(),
        };
        l.attributes.insert("class".to_owned(), "link".to_owned());
        l
    }

    /// Set the target-attribute
    pub fn set_target(&mut self, target: Option<LinkTarget>) {
        self.target = target;
    }

    /// Access an attribute on the main SVG-element that will be drawn.
    pub fn attr(&mut self, key: String) -> collections::hash_map::Entry<'_, String, String> {
        self.attributes.entry(key)
    }
}

I'm not that well versed with rust but from my understanding
pub fn new(inner: N, uri: String) -> Self {
this function is a constructor that takes an input inner with type N, N being a generic type is this acceptable?

[ralfbiedert]

Unfortunately not, and this can never work as a fundamental limitation of cross-language interop.

Simply speaking, supporting any new(inner: N) construct needs a compiler (Rust in this case), as N is something that needs to be filled in during compilation (google monomorphization).

When you author a function fn new(inner: N) {}, you abstractly write a whole family of function, and only if someone comes along and plugs in an actual type for N your new() becomes an 'actually real' function that you then can find in bit code, such as your compiled DLL. That "plugging in" happens implicitly when someone calls you at some other place in Rust source, like when someone does new(0_u32), in which case you get a new that's specific for u32 now.

So long story short, that means if you write such a generic new, you simply haven't written an actual function yet that would exist in your DLL (similarly to if you write Link<N> you haven't actually defined a type that you could find in memory that abstractly).