logistic_map multi-thread & send_message(to GenServer) . see `fn map_calc_send`

lib.rs

extern crate scoped_pool;

use rustler::types::pid::Pid;

lazy_static! {
    static ref POOL: scoped_pool::Pool = scoped_pool::Pool::new(8);
}

fn map_calc_send<'a>(env: Env<'a>, args: &[Term<'a>]) -> NifResult<Term<'a>> {
    let mut my_env = OwnedEnv::new();
    let send_pid: Pid = args[4].decode()?;

    let saved_reversed_list = my_env.run(|env| -> NifResult<SavedTerm> {
        let list_arg = args[0].in_env(env);
        let num: Term = args[1].in_env(env);
        let p: Term = args[2].in_env(env);
        let mu: Term = args[3].in_env(env);
        // Ok(my_env.save( make_tuple(env, &[list_arg, num, p, mu])) )
        Ok(my_env.save( (list_arg, num, p, mu).encode(env) ) )
    })?;
    POOL.spawn(move || {
        my_env.send_and_clear(&send_pid, |env| {
            let result: NifResult<Term> = (|| {

                let res_term = saved_reversed_list.load(env);
                let tuple = res_term.decode::<(Term, i64, i64, i64)>()?;
                let term_itr = tuple.0;
                let iter: ListIterator = term_itr.decode()?;
                let num = tuple.1;
                let p = tuple.2;
                let mu = tuple.3;

                let res: Result<Vec<i64>, Error> = iter
                        .map(|x  | x.decode::<i64>())
                        .collect();

                match res {
                    Ok(result) => Ok( {
                        let r = result.iter().map(|&x| loop_calc(num, x, p, mu)).collect::<Vec<i64>>();
                        (atoms::push(), r).encode(env)
                    } ),
                    Err(err) => Err(err)
                }
            })();

            match result {
                Err(_err) => env.error_tuple("test failed".encode(env)),
                Ok(term) => term
            }
        });
    });
    Ok(atoms::ok().to_term(env))
}