# 47 Foreign Function Interface

Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign functions must be declared inside an extern block annotated with a #[link] attribute containing the name of the foreign library.

// ffi.rs
use std::fmt;

// this extern block links to the libm library
extern {
// this is a foreign function
// that computes the square root of a single precision complex number
fn csqrtf(z: Complex) -> Complex;
}

fn main() {
// z = -1 + 0i
let z = Complex { re: -1., im: 0. };

// calling a foreign function is an unsafe operation
let z_sqrt = unsafe {
csqrtf(z)
};

println!("the square root of {:?} is {:?}", z, z_sqrt);
}

// Minimal implementation of single precision complex numbers
#[repr(C)]
#[derive(Copy)]
struct Complex {
re: f32,
im: f32,
}

impl fmt::Debug for Complex {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.im < 0. {
write!(f, "{}-{}i", self.re, -self.im)
} else {
write!(f, "{}+{}i", self.re, self.im)
}
}
}

$rustc ffi.rs && ./ffi the square root of -1+0i is 0+1i  Since calling foreign functions is considered unsafe, it's common to write safe wrappers around them. // safe.rs use std::fmt; #[link(name = "m")] extern { fn ccosf(z: Complex) -> Complex; } // safe wrapper fn cos(z: Complex) -> Complex { unsafe { ccosf(z) } } fn main() { // z = 0 + 1i let z = Complex { re: 0., im: 1. }; println!("cos({:?}) = {:?}", z, cos(z)); } // Minimal implementation of single precision complex numbers #[repr(C)] #[derive(Copy)] struct Complex { re: f32, im: f32, } impl fmt::Debug for Complex { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.im < 0. { write!(f, "{}-{}i", self.re, -self.im) } else { write!(f, "{}+{}i", self.re, self.im) } } }  $ rustc safe.rs && ./safe
cos(0+1i) = 1.543081+0i