Does Rust allow distributing closed-source libraries?

Question

I'm new at rust and just finished the book. I'm trying to understand whether everything in rust must be distributed in the form of source code, like golang perhaps. This may not be the accurate way to ask but here's what I want to know about:

In the age of C/C++ I can compile code into some library (xx.a or xx.so) and distribute it with header files to someone who can link their code with as long as we are using about the same compiler/os/platform. Now with Rust every dependency is pulled from crates.io in the form of source code and locally built and linked. However if for some reason I do not want to publish the source code but only the target platform's library can this be done though manipulating the tool chain? I believe this cannot be done because of some Rust's inherent design. For example I can write code like this in a rust library:

pub trait Summary {
  // snip
}

fn returns_summarizable() -> impl Summary {
  // snip
}

If the code that depend on the library calls returns_summarizable then the compiler must be able to determine the size of the return value to allocate space on stack for the result variable. This means although the code only care that it returns some type that implements the Summary trait but the compiler actually has to know the concrete type it returns. This can not be done without the library's source code, not even with some equivalent thing like header files because the header file (if exists) should only contain the trait declaration other than any inner type the function could possibly return.

I'm curious about it not because I want to distribute crates without source but it occurs to me that the borrow checker and compiler never looks at the body of a function or method where it's called but only the signature. This seems not to be the case when a function returns impl xxx as above, because Rust has to look at the implementation type that's actually returned to determine the return type size, right?

Answer 1

The main problem here is that the Rust ABI is not stable yet. So it's hard to properly distribute "Rust binary files" since they are only known to work with the exact same compiler you compiled them with. Even a minor version change might break them.

The safe bet for now is to distribute a staticlib and/or cdylib by setting the crates type in Cargo.toml

[lib]
crate-type = ["staticlib", "cdylib"]

wich will produce a static library file *.a and a dynamic library file *.so/*.dylib/*.dll respectively, see the reference article on linkage.

The disadvantage is that this uses the FFI interface and as a result you loose some of Rusts expressiveness and can only use C compatible types which rules out things like generics.

If you don't mind breaking/rebuilding every Rust minor release you can use a Rust dylib:

[lib]
crate-type = ["dylib"]

which will produce a lib<your_crate_name>.so on Linux. You can then tell cargo to link that file with a build script or similar:

fn main() {
    println!("cargo:rustc-link-lib=dy_lib");
    println!("cargo:rustc-link-search=/home/jona/projects/dy-lib/target/release");
}

You'll also have to provide the function signatures in an extern block either directly where you use it or in a stub library:

extern "Rust" {
    fn your_exported_function(Vec<i8>, String) -> Result<(), &'static str>;
}

Note that since generics are implemented by monomorphization, that still doesn't allow them, but you can at least use the rest of Rusts expressive type system though all functions in an extern block are implicitly unsafe.

Answer 2

Although you can return impl Summary, it doesn't seem that you can return two different types anyhow dynamically, for example this code fails to compile. Playground:

use rand;

trait Summary {
    fn get(&self) -> usize;
}

struct A(usize);
impl Summary for A { 
    fn get(&self) -> usize { return self.0; } 
}
struct B(usize);
impl Summary for B { 
    fn get(&self) -> usize { return self.0; } 
}

fn returns_summarizable() -> impl Summary {
    if rand::random() {
        return A(42);
    } else {
        return B(21);
    }
}

fn main() {
    println!("{}", returns_summarizable().get());
}

error[E0308]: mismatched types
  --> src/main.rs:20:16
   |
16 | fn returns_summarizable() -> impl Summary {
   |                              ------------ expected `A` because of return type
...
20 |         return B(21);
   |                ^^^^^ expected struct `A`, found struct `B`

It works though, if both branches return type A, and thus the code randomly prints 42 or 21. So as long as it returns only one type, the compiler can replace impl Summary in the binary signature with the size of A