Skip to content

Instantly share code, notes, and snippets.


Block or report user

Report or block kyren

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
use std::fmt;
use failure::{Error, Fail};
/// Wraps an `Error` in a type that displays the full cause chain of that error and all available
/// backtraces.
pub struct DisplayErrorCauses(pub Error);
/// Wraps any `Fail` type in a type that displays its full cause chain and all available backtraces.
pub struct DisplayFailureCauses<F: Fail>(pub F);
use std::{iter, slice, vec};
use std::iter::FromIterator;
/// A unique identifier with an associated usize index. Indexes are valued proportional to the
/// number of indexes allocated, are reused after being freed, and do not grow without bound. When
/// an index is re-used, an associated "generation" is incremented, so that within the life of a
/// single allocator, no two GenerationalIndex values will ever be equal. Since the indexes do not
/// grow without bound, GenerationalIndex values are particularly suited to being stored by their
/// index in extremely fast contiguous arrays.
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug)]
use std::path::PathBuf;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::thread;
use std::os::raw::c_void;
use std::rc::Rc;
use std::cell::{Cell, RefCell};
use std::i16;
use std::time::Instant;
use failure::{err_msg, Error};
View test.lua
function hook(args)
print("greetings from lua")
for _, v in pairs(args) do
return 1
extern crate rlua;
use std::env;
use std::fs::File;
use std::io::Read;
use rlua::prelude::*;
fn main() {
let mut args = env::args();
use std::result::Result;
use std::thread::{spawn, JoinHandle};
use std::sync::{Arc, Mutex};
use std::sync::mpsc::{sync_channel, channel, SyncSender, Receiver, TryRecvError, RecvTimeoutError};
use std::boxed::FnBox;
use std::time::Duration;
/// Holds a piece of data in a particular thread and produces promises that are executed on that
/// thread only. Useful for paralellization or concurrency with types that do not implement Send.
pub struct ThreadWorker<T> {
You can’t perform that action at this time.