Fork 0
Rust interface and bindings for notmuch (Downstream Fork) https://github.com/vhdirk/notmuch-rs
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Go to file
eaon ba03b994b3
Switch to `where` syntax
5 years ago
src Switch to `where` syntax 5 years ago
tests trust clippy and rustfmt 5 years ago
.gitignore Add .gitignore file. 8 years ago
.travis.yml prevent travis from building with features that are not available 5 years ago
Cargo.toml bump version 5 years ago
LICENSE.md add license 5 years ago
README.md Simplify example in README 5 years ago



This is not much more than a wrapper for the notmuch C api.

Build Status Crate version Download statistics License


notmuch-rs expects libnotmuch development files to be installed on your system.


Add this to your Cargo.toml:

notmuch = "*"

and this to your crate root:

extern crate notmuch;


extern crate notmuch;
use notmuch::StreamingIterator;

fn main() {

    let mut mail_path = std::env::home_dir().unwrap();

    let db = notmuch::Database::open(&mail_path, notmuch::DatabaseMode::ReadOnly).unwrap();
    let query = db.create_query("").unwrap();
    let mut threads = query.search_threads().unwrap();

    while let Some(thread) = threads.next() {
        println!("thread {:?} {:?}", thread.subject(), thread.authors());


Notmuch makes no claims regarding thread safety. It does not seem to use any thread locals, but I did not spot any locks. So, as far as I am concerned, it is not thread safe.
So why do all structs implement Send and Sync? Well, it is safe to access pointers from different threads (as long as you know what you are doing :) ). Up till now I haven't done a lot of multithreaded stuff with notmuch-rs. If you feel this is too permissive, let me know.


All structs are strictly linked together with their lifetime. The root of the tree is Database, which has a lifetime that must outlive any child objects, for instance Query. The Threads iterator that you can get from a Query is always outlived by the parent query. Threads in its turn must have a longer life than Thread, which in turn must outlive Messages and so on. Each structure keeps a PhantomData marker of its owner.

Using this in an application poses significant difficulties in satisfying these lifetime requirements. To alleviate this, notmuch-rs makes use of the excellent Supercow, so you don't have to use crates like owningref or rental to get around this.

This way, you get to choose your own container type, and even keep the parent object alive so you don't have to juggle lifetimes. To use this, most types are accompagnied with an *Ext trait, that accepts Rc, Arc or comparable.

    use std::sync::Arc;
    use notmuch::{DatabaseExt};

    let query = {
        let dbr = Arc::new(db);

        <Database as DatabaseExt>::create_query(dbr.clone(), &"".to_string()).unwrap()


Since the lifetime of a Thread or a Message is dependent on the Threads and Messages iterator respectively, using the regular rust Iterator trait proved impossible. As such, notmuch-rs includes a StreamingIterator (and additional StreamingIteratorExt) trait that is used to iterate while satisfying the lifetime constraints.


notmuch-rs started out from the following projects:

Any contributions are welcome!