pythonesque

#![feature(macro_rules)]
extern crate collections;
extern crate sync;

use std::sync::{Arc, Mutex, RWLock, RWLockReadGuard};
use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUint, Ordering, Relaxed, SeqCst};
use std::ptr;
use std::ptr::{RawMutPtr};
use std::slice::Items;

pythonesque

• Start Date: 2014-11-10
• RFC PR: (leave this empty)
• Rust Issue: (leave this empty)

Summary

I propose altering the Send trait as proposed by RFC #17 as follows:

• Remove the implicit 'static bound from Send.

pythonesque

use std::collections::{dlist, DList, HashSet, Deque};
use std::hash::Hash;
use std::iter;
use std::default::Default;

pub struct LinkedHashSet<'a, T: 'a> where T: Hash + Eq {
    // Important: HashSet must come after DList, since destructors run in
    // reverse order.  Otherwise we'd have use after free (potentially).
    element_list: DList<T>,
    element_set: HashSet<&'a T>,

pythonesque

#![feature(if_let)]

use nomove::{freeze, freeze_box, FreezeSlice, NoMoveGuard};
use std::cell::Cell;

mod nomove {
    pub struct NoMoveGuard<T> {
        pub data: T,
        no_copy: ::std::kinds::marker::NoCopy,
    }

pythonesque

#![feature(unsafe_destructor)]

use rooted::{RcSend, Root};
use std::fmt;
use std::rc::Rc;

mod rooted {
    use std::collections::trie_map::{mod, TrieMap};
    use std::fmt;
    use std::kinds::marker;

pythonesque

#![feature(rustc_private,std_misc)]

extern crate arena;

use arena::TypedArena;
use std::cell::Cell;
use std::collections::hash_map::Entry as h;
use std::collections::HashMap;
use std::default::Default;
use std::fmt;

pythonesque

#![feature(if_let)]

extern crate arena;

use arena::TypedArena;
use std::cell::Cell;
use std::fmt;

type NodeRef<'a, T> = Cell<Option<&'a Node<'a, T>>>;

pythonesque

use list::Node;

mod list {
    use std::mem;

    #[derive(Show)]    
    pub struct Node<T> {
        pub data: T,
        prev: Option<Box<Node<T>>>,
        next: Option<Box<Node<T>>>

pythonesque

use std::default::Default;
use std::num::Zero;
use std::slice::MutItems;

pub struct Matrix<T> {
	values: Vec<T>,
	rows: uint,
	columns: uint,
}

pythonesque

#![feature(optin_builtin_traits,unsafe_destructor)]

pub mod recursive_mutex {
    #![allow(unstable)]

    use std::cell::UnsafeCell;
    use std::sync::Semaphore;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::thread::Thread;