Dataloader

Build Status Crates.io Coverage Status

Rust implementation of Facebook's DataLoader using futures.

Documentation

Features

Usage

Add to your Cargo.toml: ```toml [dependencies] dataloader = "0.8" futures = { version = "0.3" } async-trait = "0.1"

[dependencies.async-std] version = "1.0" features = ["unstable"] ```

example: ```rust use asyncstd::prelude::*; use asyncstd::task; use asynctrait::asynctrait; use dataloader::eager::cached::Loader; use dataloader::BatchFn; use std::collections::HashMap; use std::thread;

struct MyLoadFn;

[async_trait]

impl BatchFn for MyLoadFn { type Error = ();

fn max_batch_size(&self) -> usize {
    4
}

async fn load(&self, keys: &[usize]) -> HashMap<usize, Result<usize, Self::Error>> {
    println!("BatchFn load keys {:?}", keys);
    keys.iter()
        .map(|v| (v.clone(), Ok(v.clone())))
        .collect::<HashMap<_, _>>()
}

}

fn main() { let mut i = 0; while i < 2 { let a = MyLoadFn; let loader = Loader::new(a);

    let l1 = loader.clone();
    let h1 = thread::spawn(move || {
        let r1 = l1.load(1);
        let r2 = l1.load(2);
        let r3 = l1.load(3);

        let r4 = l1.load_many(vec![2, 3, 4, 5, 6, 7, 8]);
        let f = r1.join(r2).join(r3).join(r4);
        println!("{:?}", task::block_on(f));
    });

    let l2 = loader.clone();
    let h2 = thread::spawn(move || {
        let r1 = l2.load(1);
        let r2 = l2.load(2);
        let r3 = l2.load(3);
        let r4 = l2.load(4);
        let f = r1.join(r2).join(r3).join(r4);
        println!("{:?}", task::block_on(f));
    });

    h1.join().unwrap();
    h2.join().unwrap();
    i += 1;
}

} ```

LICENSE

This project is licensed under either of

at your option.