}
struct FooClosure<'a> {
- myfunc: 'a |int, uint| -> i32
+ myfunc: |int, uint|: 'a -> i32
}
fn a(a: int, b: uint) -> i32 {
let mut x = add(5,7);
-type Binop<'a> = 'a |int,int| -> int;
+type Binop<'a> = |int,int|: 'a -> int;
let bo: Binop = add;
x = bo(5,7);
~~~~
map.insert(*k, 1);
}
- rng.shuffle_mut(keys);
+ rng.shuffle(keys);
// measure
let mut i = 0;
}
struct BasicLoop {
- work: ~[proc:Send()], // pending work
+ work: ~[proc():Send], // pending work
idle: Option<*mut BasicPausable>, // only one is allowed
remotes: ~[(uint, ~Callback:Send)],
next_remote: uint,
}
}
- fn callback(&mut self, f: proc:Send()) {
+ fn callback(&mut self, f: proc():Send) {
self.work.push(f);
}
// except according to those terms.
#![feature(globs)]
-#![crate_id = "libc#0.10-pre"]
+#![crate_id = "libc#0.11-pre"]
#![experimental]
#![no_std] // we don't need std, and we can't have std, since it doesn't exist
// yet. std depends on us.
#![allow(missing_doc)]
#![allow(uppercase_variables)]
-#![feature(link_args)] // NOTE: remove after stage0
-
#[cfg(test)] extern crate std;
#[cfg(test)] extern crate test;
#[cfg(test)] extern crate native;
#[link(name = "m")]
extern {}
-// NOTE: remove this after a stage0 snap
-#[cfg(stage0, windows)]
-#[link_args = "-Wl,--enable-long-section-names"]
-extern {}
-
/// A wrapper for a nullable pointer. Don't use this except for interacting
/// with libc. Basically Option, but without the dependance on libstd.
// If/when libprim happens, this can be removed in favor of that
}
#[cfg(unix)]
-fn with_argv<T>(prog: &str, args: &[~str], cb: proc:(**libc::c_char) -> T) -> T {
+fn with_argv<T>(prog: &str, args: &[~str], cb: proc(**libc::c_char) -> T) -> T {
use std::slice;
// We can't directly convert `str`s into `*char`s, as someone needs to hold
}
#[cfg(unix)]
-fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: proc:(*c_void) -> T) -> T {
+fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: proc(*c_void) -> T) -> T {
use std::slice;
// On posixy systems we can pass a char** for envp, which is a
}
/// Spawns a function with the default configuration
-pub fn spawn(f: proc:Send()) {
+pub fn spawn(f: proc():Send) {
spawn_opts(TaskOpts::new(), f)
}
/// Spawns a new task given the configuration options and a procedure to run
/// inside the task.
-pub fn spawn_opts(opts: TaskOpts, f: proc:Send()) {
+pub fn spawn_opts(opts: TaskOpts, f: proc():Send) {
let TaskOpts {
notify_chan, name, stack_size,
stderr, stdout,
}
}
- fn spawn_sibling(~self, mut cur_task: ~Task, opts: TaskOpts, f: proc:Send()) {
+ fn spawn_sibling(~self, mut cur_task: ~Task, opts: TaskOpts, f: proc():Send) {
cur_task.put_runtime(self);
Local::put(cur_task);
symmetric: bool,
x_tab: ziggurat_tables::ZigTable,
f_tab: ziggurat_tables::ZigTable,
- pdf: 'static |f64| -> f64,
- zero_case: 'static |&mut R, f64| -> f64)
+ pdf: |f64|: 'static -> f64,
+ zero_case: |&mut R, f64|: 'static -> f64)
-> f64 {
static SCALE: f64 = (1u64 << 53) as f64;
loop {
#[test]
fn test_shuffle() {
let mut r = task_rng();
- let mut empty: &mut [int] = &mut [];
+ let empty: &mut [int] = &mut [];
r.shuffle(empty);
let mut one = [1];
r.shuffle(one);
use syntax::codemap;
struct Context<'a> {
- in_cfg: 'a |attrs: &[ast::Attribute]| -> bool,
+ in_cfg: |attrs: &[ast::Attribute]|: 'a -> bool,
}
// Support conditional compilation by transforming the AST, stripping out
///
/// The diagnostic emitter yielded to the procedure should be used for reporting
/// errors of the compiler.
-pub fn monitor(f: proc:Send()) {
+pub fn monitor(f: proc():Send) {
// FIXME: This is a hack for newsched since it doesn't support split stacks.
// rustc needs a lot of stack! When optimizations are disabled, it needs
// even *more* stack than usual as well.
ret
}
-pub type GetCrateDataCb<'a> = 'a |ast::CrateNum| -> Cmd;
+pub type GetCrateDataCb<'a> = |ast::CrateNum|: 'a -> Cmd;
pub fn maybe_find_item<'a>(item_id: ast::NodeId,
items: ebml::Doc<'a>) -> Option<ebml::Doc<'a>> {
item_path(lookup_item(id, cdata.data()))
}
-pub type DecodeInlinedItem<'a> = 'a |cdata: @cstore::crate_metadata,
- tcx: &ty::ctxt,
-
path: Vec<ast_map::PathElem>,
- par_doc: ebml::Doc|
-
-> Result<ast::InlinedItem, Vec<ast_map::PathElem> >;
+pub type DecodeInlinedItem<'a> = |cdata: @cstore::crate_metadata,
+ tcx: &ty::ctxt,
+ path: Vec<ast_map::PathElem>,
+ par_doc: ebml::Doc|: 'a
+ -> Result<ast::InlinedItem, Vec<ast_map::PathElem> >;
pub fn maybe_get_item_ast(cdata: Cmd, tcx: &ty::ctxt, id: ast::NodeId,
decode_inlined_item: DecodeInlinedItem)
pub type Encoder<'a> = writer::Encoder<'a, MemWriter>;
-pub type EncodeInlinedItem<'a> = 'a |ecx: &EncodeContext,
- ebml_w: &mut Encoder,
- ii: InlinedItemRef|;
+pub type EncodeInlinedItem<'a> = |ecx: &EncodeContext,
+ ebml_w: &mut Encoder,
+ ii: InlinedItemRef|: 'a;
pub struct EncodeParams<'a> {
pub diag: &'a SpanHandler,
/// Functions with type `pick` take a parent directory as well as
/// a file found in that directory.
-pub type pick<'a> = 'a |path: &Path| -> FileMatch;
+pub type pick<'a> = |path: &Path|: 'a -> FileMatch;
pub struct FileSearch<'a> {
pub sysroot: &'a Path,
RegionParameter,
}
pub type conv_did<'a> =
- 'a |source: DefIdSource, ast::DefId| -> ast::DefId;
+ |source: DefIdSource, ast::DefId|: 'a -> ast::DefId;
pub struct PState<'a> {
data: &'a [u8],
}
}
-type enter_pat<'a> = 'a |@ast::Pat| -> Option<Vec<@ast::Pat>>;
+type enter_pat<'a> = |@ast::Pat|: 'a -> Option<Vec<@ast::Pat>>;
fn enter_match<'r,'b>(
bcx: &'b Block<'b>,
}
pub type val_and_ty_fn<'r,'b> =
- 'r |&'b Block<'b>, ValueRef, ty::t| -> &'b Block<'b>;
+ |&'b Block<'b>, ValueRef, ty::t|: 'r -> &'b Block<'b>;
// Iterates through the elements of a structural type.
pub fn iter_structural_ty<'r,
}
pub type iter_vec_block<'r,'b> =
- 'r |&'b Block<'b>, ValueRef, ty::t| -> &'b Block<'b>;
+ |&'b Block<'b>, ValueRef, ty::t|: 'r -> &'b Block<'b>;
pub fn iter_vec_loop<'r,
'b>(
pub struct BottomUpFolder<'a> {
pub tcx: &'a ty::ctxt,
- pub fldop: 'a |ty::t| -> ty::t,
+ pub fldop: |ty::t|: 'a -> ty::t,
}
impl<'a> TypeFolder for BottomUpFolder<'a> {
pub struct RegionFolder<'a> {
tcx: &'a ty::ctxt,
- fld_t: 'a |ty::t| -> ty::t,
- fld_r: 'a |ty::Region| -> ty::Region,
+ fld_t: |ty::t|: 'a -> ty::t,
+ fld_r: |ty::Region|: 'a -> ty::Region,
}
impl<'a> RegionFolder<'a> {
pub fn general(tcx: &'a ty::ctxt,
- fld_r: 'a |ty::Region| -> ty::Region,
- fld_t: 'a |ty::t| -> ty::t)
+ fld_r: |ty::Region|: 'a -> ty::Region,
+ fld_t: |ty::t|: 'a -> ty::t)
-> RegionFolder<'a> {
RegionFolder {
tcx: tcx,
}
}
- pub fn regions(tcx: &'a ty::ctxt, fld_r: 'a |ty::Region| -> ty::Region)
+ pub fn regions(tcx: &'a ty::ctxt, fld_r: |ty::Region|: 'a -> ty::Region)
-> RegionFolder<'a> {
fn noop(t: ty::t) -> ty::t { t }
struct RegionRelator<'a> {
tcx: &'a ty::ctxt,
stack: Vec<ty::Region>,
- relate_op: 'a |ty::Region, ty::Region|,
+ relate_op: |ty::Region, ty::Region|: 'a,
}
// FIXME(#10151) -- Define more precisely when a region is
}
pub type LatticeOp<'a, T> =
- 'a |cf: &CombineFields, a: &T, b: &T| -> cres<T>;
+ |cf: &CombineFields, a: &T, b: &T|: 'a -> cres<T>;
impl LatticeValue for ty::t {
fn sub(cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures {
}
}
-pub type LatticeDirOp<'a, T> = 'a |a: &T, b: &T| -> cres<T>;
+pub type LatticeDirOp<'a, T> = |a: &T, b: &T|: 'a -> cres<T>;
#[deriving(Clone)]
pub enum LatticeVarResult<V,T> {
}
struct LoopQueryVisitor<'a> {
- p: 'a |&ast::Expr_| -> bool,
+ p: |&ast::Expr_|: 'a -> bool,
flag: bool,
}
}
struct BlockQueryVisitor<'a> {
- p: 'a |&ast::Expr| -> bool,
+ p: |&ast::Expr|: 'a -> bool,
flag: bool,
}
pub struct CVec<T> {
base: *mut T,
len: uint,
- dtor: Option<proc:Send()>,
+ dtor: Option<proc():Send>,
}
#[unsafe_destructor]
/// * dtor - A proc to run when the value is destructed, useful
/// for freeing the buffer, etc.
pub unsafe fn new_with_dtor(base: *mut T, len: uint,
- dtor: proc:Send()) -> CVec<T> {
+ dtor: proc():Send) -> CVec<T> {
assert!(base != ptr::mut_null());
CVec {
base: base,
use io::*;
use io::test::*;
- pub fn smalltest(server: proc:Send(UnixStream), client: proc:Send(UnixStream)) {
+ pub fn smalltest(server: proc(UnixStream):Send, client: proc(UnixStream):Send) {
let path1 = next_test_unix();
let path2 = path1.clone();
/// assert!(it.next().is_none());
/// ```
#[inline]
- fn map<'r, B>(self, f: 'r |A| -> B) -> Map<'r, A, B, Self> {
+ fn map<'r, B>(self, f: |A|: 'r -> B) -> Map<'r, A, B, Self> {
Map{iter: self, f: f}
}
/// assert!(it.next().is_none());
/// ```
#[inline]
- fn filter<'r>(self, predicate: 'r |&A| -> bool) -> Filter<'r, A, Self> {
+ fn filter<'r>(self, predicate: |&A|: 'r -> bool) -> Filter<'r, A, Self> {
Filter{iter: self, predicate: predicate}
}
/// assert!(it.next().is_none());
/// ```
#[inline]
- fn filter_map<'r, B>(self, f: 'r |A| -> Option<B>) -> FilterMap<'r, A, B, Self> {
+ fn filter_map<'r, B>(self, f: |A|: 'r -> Option<B>) -> FilterMap<'r, A, B, Self> {
FilterMap { iter: self, f: f }
}
/// assert!(it.next().is_none());
/// ```
#[inline]
- fn skip_while<'r>(self, predicate: 'r |&A| -> bool) -> SkipWhile<'r, A, Self> {
+ fn skip_while<'r>(self, predicate: |&A|: 'r -> bool) -> SkipWhile<'r, A, Self> {
SkipWhile{iter: self, flag: false, predicate: predicate}
}
/// assert!(it.next().is_none());
/// ```
#[inline]
- fn take_while<'r>(self, predicate: 'r |&A| -> bool) -> TakeWhile<'r, A, Self> {
+ fn take_while<'r>(self, predicate: |&A|: 'r -> bool) -> TakeWhile<'r, A, Self> {
TakeWhile{iter: self, flag: false, predicate: predicate}
}
/// assert!(it.next().is_none());
/// ```
#[inline]
- fn scan<'r, St, B>(self, initial_state: St, f: 'r |&mut St, A| -> Option<B>)
+ fn scan<'r, St, B>(self, initial_state: St, f: |&mut St, A|: 'r -> Option<B>)
-> Scan<'r, A, B, Self, St> {
Scan{iter: self, f: f, state: initial_state}
}
/// }
/// ```
#[inline]
- fn flat_map<'r, B, U: Iterator<B>>(self, f: 'r |A| -> U)
+ fn flat_map<'r, B, U: Iterator<B>>(self, f: |A|: 'r -> U)
-> FlatMap<'r, A, Self, U> {
FlatMap{iter: self, f: f, frontiter: None, backiter: None }
}
/// println!("{}", sum);
/// ```
#[inline]
- fn inspect<'r>(self, f: 'r |&A|) -> Inspect<'r, A, Self> {
+ fn inspect<'r>(self, f: |&A|: 'r) -> Inspect<'r, A, Self> {
Inspect{iter: self, f: f}
}
/// An iterator which maps the values of `iter` with `f`
pub struct Map<'a, A, B, T> {
iter: T,
- f: 'a |A| -> B
+ f: |A|: 'a -> B
}
impl<'a, A, B, T> Map<'a, A, B, T> {
/// An iterator which filters the elements of `iter` with `predicate`
pub struct Filter<'a, A, T> {
iter: T,
- predicate: 'a |&A| -> bool
+ predicate: |&A|: 'a -> bool
}
impl<'a, A, T: Iterator<A>> Iterator<A> for Filter<'a, A, T> {
/// An iterator which uses `f` to both filter and map elements from `iter`
pub struct FilterMap<'a, A, B, T> {
iter: T,
- f: 'a |A| -> Option<B>
+ f: |A|: 'a -> Option<B>
}
impl<'a, A, B, T: Iterator<A>> Iterator<B> for FilterMap<'a, A, B, T> {
pub struct SkipWhile<'a, A, T> {
iter: T,
flag: bool,
- predicate: 'a |&A| -> bool
+ predicate: |&A|: 'a -> bool
}
impl<'a, A, T: Iterator<A>> Iterator<A> for SkipWhile<'a, A, T> {
pub struct TakeWhile<'a, A, T> {
iter: T,
flag: bool,
- predicate: 'a |&A| -> bool
+ predicate: |&A|: 'a -> bool
}
impl<'a, A, T: Iterator<A>> Iterator<A> for TakeWhile<'a, A, T> {
/// An iterator to maintain state while iterating another iterator
pub struct Scan<'a, A, B, T, St> {
iter: T,
- f: 'a |&mut St, A| -> Option<B>,
+ f: |&mut St, A|: 'a -> Option<B>,
/// The current internal state to be passed to the closure next.
pub state: St,
///
pub struct FlatMap<'a, A, T, U> {
iter: T,
- f: 'a |A| -> U,
+ f: |A|: 'a -> U,
frontiter: Option<U>,
backiter: Option<U>,
}
/// element before yielding it.
pub struct Inspect<'a, A, T> {
iter: T,
- f: 'a |&A|
+ f: |&A|: 'a
}
impl<'a, A, T> Inspect<'a, A, T> {
/// An iterator which just modifies the contained state throughout iteration.
pub struct Unfold<'a, A, St> {
- f:
'a |&mut St| -> Option<A>,
+ f:
|&mut St|: 'a -> Option<A>,
/// Internal state that will be yielded on the next iteration
pub state: St,
}
/// Creates a new iterator with the specified closure as the "iterator
/// function" and an initial state to eventually pass to the iterator
#[inline]
- pub fn new<'a>(initial_state: St, f:
'a |&mut St| -> Option<A>)
+ pub fn new<'a>(initial_state: St, f:
|&mut St|: 'a -> Option<A>)
-> Unfold<'a, A, St> {
Unfold {
f: f,
#![no_std]
#![deny(missing_doc)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
// When testing libstd, bring in libuv as the I/O backend so tests can print
// things and all of the std::io tests have an I/O interface to run on top
use unstable::sync::Exclusive;
use slice::OwnedVector;
-type Queue = Exclusive<~[proc:Send()]>;
+type Queue = Exclusive<~[proc():Send]>;
// You'll note that these variables are *not* atomic, and this is done on
// purpose. This module is designed to have init() called *once* in a
}
}
-pub fn push(f: proc:Send()) {
+pub fn push(f: proc():Send) {
unsafe {
rtassert!(!RUNNING);
rtassert!(!QUEUE.is_null());
// Miscellaneous calls which are very different depending on what context
// you're in.
- fn spawn_sibling(~self, cur_task: ~Task, opts: TaskOpts, f: proc:Send());
+ fn spawn_sibling(~self, cur_task: ~Task, opts: TaskOpts, f: proc():Send);
fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>>;
/// The (low, high) edges of the current stack.
fn stack_bounds(&self) -> (uint, uint); // (lo, hi)
///
/// It is forbidden for procedures to register more `at_exit` handlers when they
/// are running, and doing so will lead to a process abort.
-pub fn at_exit(f: proc:Send()) {
+pub fn at_exit(f: proc():Send) {
at_exit_imp::push(f);
}
pub trait EventLoop {
fn run(&mut self);
- fn callback(&mut self, arg: proc:Send());
+ fn callback(&mut self, arg: proc():Send);
fn pausable_idle_callback(&mut self,
~Callback:Send) -> ~PausableIdleCallback:Send;
fn remote_callback(&mut self, ~Callback:Send) -> ~RemoteCallback:Send;
pub enum DeathAction {
/// Action to be done with the exit code. If set, also makes the task wait
/// until all its watched children exit before collecting the status.
- Execute(proc:Send(TaskResult)),
+ Execute(proc(TaskResult):Send),
/// A channel to send the result of the task on when the task exits
SendMessage(Sender<TaskResult>),
}
/// Spawns a sibling to this task. The newly spawned task is configured with
/// the `opts` structure and will run `f` as the body of its code.
- pub fn spawn_sibling(mut ~self, opts: TaskOpts, f: proc:Send()) {
+ pub fn spawn_sibling(mut ~self, opts: TaskOpts, f: proc():Send) {
let ops = self.imp.take_unwrap();
ops.spawn_sibling(self, opts, f)
}
/// to finish executing. This means that even if `join` is not explicitly
/// called, when the `Thread` falls out of scope its destructor will block
/// waiting for the OS thread.
- pub fn start<T: Send>(main: proc:Send() -> T) -> Thread<T> {
+ pub fn start<T: Send>(main: proc():Send -> T) -> Thread<T> {
Thread::start_stack(DEFAULT_STACK_SIZE, main)
}
/// Performs the same functionality as `start`, but specifies an explicit
/// stack size for the new thread.
- pub fn start_stack<T: Send>(stack: uint, main: proc:Send() -> T) -> Thread<T> {
+ pub fn start_stack<T: Send>(stack: uint, main: proc():Send -> T) -> Thread<T> {
// We need the address of the packet to fill in to be stable so when
// `main` fills it in it's still valid, so allocate an extra ~ box to do
/// This corresponds to creating threads in the 'detached' state on unix
/// systems. Note that platforms may not keep the main program alive even if
/// there are detached thread still running around.
- pub fn spawn(main: proc:Send()) {
+ pub fn spawn(main: proc():Send) {
Thread::spawn_stack(DEFAULT_STACK_SIZE, main)
}
/// Performs the same functionality as `spawn`, but explicitly specifies a
/// stack size for the new thread.
- pub fn spawn_stack(stack: uint, main: proc:Send()) {
+ pub fn spawn_stack(stack: uint, main: proc():Send) {
unsafe {
let handle = imp::create(stack, ~main);
imp::detach(handle);
pub type rust_thread = HANDLE;
pub type rust_thread_return = DWORD;
- pub unsafe fn create(stack: uint, p: ~proc:Send()) -> rust_thread {
+ pub unsafe fn create(stack: uint, p: ~proc():Send) -> rust_thread {
let arg: *mut libc::c_void = cast::transmute(p);
// FIXME On UNIX, we guard against stack sizes that are too small but
// that's because pthreads enforces that stacks are at least
pub type rust_thread = libc::pthread_t;
pub type rust_thread_return = *u8;
- pub unsafe fn create(stack: uint, p: ~proc:Send()) -> rust_thread {
+ pub unsafe fn create(stack: uint, p: ~proc():Send) -> rust_thread {
let mut native: libc::pthread_t = mem::uninit();
let mut attr: libc::pthread_attr_t = mem::uninit();
assert_eq!(pthread_attr_init(&mut attr), 0);
pub struct Splits<'a, T> {
v: &'a [T],
n: uint,
- pred: 'a |t: &T| -> bool,
+ pred: |t: &T|: 'a -> bool,
finished: bool
}
pub struct RevSplits<'a, T> {
v: &'a [T],
n: uint,
- pred: 'a |t: &T| -> bool,
+ pred: |t: &T|: 'a -> bool,
finished: bool
}
/// Returns an iterator over the subslices of the vector which are
/// separated by elements that match `pred`. The matched element
/// is not contained in the subslices.
- fn split(self, pred: 'a |&T| -> bool) -> Splits<'a, T>;
+ fn split(self, pred: |&T|: 'a -> bool) -> Splits<'a, T>;
/// Returns an iterator over the subslices of the vector which are
/// separated by elements that match `pred`, limited to splitting
/// at most `n` times. The matched element is not contained in
/// the subslices.
- fn splitn(self, n: uint, pred: 'a |&T| -> bool) -> Splits<'a, T>;
+ fn splitn(self, n: uint, pred: |&T|: 'a -> bool) -> Splits<'a, T>;
/// Returns an iterator over the subslices of the vector which are
/// separated by elements that match `pred`. This starts at the
/// end of the vector and works backwards. The matched element is
/// not contained in the subslices.
- fn rsplit(self, pred: 'a |&T| -> bool) -> RevSplits<'a, T>;
+ fn rsplit(self, pred: |&T|: 'a -> bool) -> RevSplits<'a, T>;
/// Returns an iterator over the subslices of the vector which are
/// separated by elements that match `pred` limited to splitting
/// at most `n` times. This starts at the end of the vector and
/// works backwards. The matched element is not contained in the
/// subslices.
- fn rsplitn(self, n: uint, pred: 'a |&T| -> bool) -> RevSplits<'a, T>;
+ fn rsplitn(self, n: uint, pred: |&T|: 'a -> bool) -> RevSplits<'a, T>;
/**
* Returns an iterator over all contiguous windows of length
}
#[inline]
- fn split(self, pred: 'a |&T| -> bool) -> Splits<'a, T> {
+ fn split(self, pred: |&T|: 'a -> bool) -> Splits<'a, T> {
self.splitn(uint::MAX, pred)
}
#[inline]
- fn splitn(self, n: uint, pred: 'a |&T| -> bool) -> Splits<'a, T> {
+ fn splitn(self, n: uint, pred: |&T|: 'a -> bool) -> Splits<'a, T> {
Splits {
v: self,
n: n,
}
#[inline]
- fn rsplit(self, pred: 'a |&T| -> bool) -> RevSplits<'a, T> {
+ fn rsplit(self, pred: |&T|: 'a -> bool) -> RevSplits<'a, T> {
self.rsplitn(uint::MAX, pred)
}
#[inline]
- fn rsplitn(self, n: uint, pred: 'a |&T| -> bool) -> RevSplits<'a, T> {
+ fn rsplitn(self, n: uint, pred: |&T|: 'a -> bool) -> RevSplits<'a, T> {
RevSplits {
v: self,
n: n,
/// Returns an iterator over the mutable subslices of the vector
/// which are separated by elements that match `pred`. The
/// matched element is not contained in the subslices.
- fn mut_split(self, pred: 'a |&T| -> bool) -> MutSplits<'a, T>;
+ fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T>;
/**
* Returns an iterator over `size` elements of the vector at a time.
}
#[inline]
- fn mut_split(self, pred: 'a |&T| -> bool) -> MutSplits<'a, T> {
+ fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T> {
MutSplits { v: self, pred: pred, finished: false }
}
/// by elements that match `pred`.
pub struct MutSplits<'a, T> {
v: &'a mut [T],
- pred: 'a |t: &T| -> bool,
+ pred: |t: &T|: 'a -> bool,
finished: bool
}
fn only_ascii(&self) -> bool { (*self as uint) < 128 }
}
-impl<'a> CharEq for 'a |char| -> bool {
+impl<'a> CharEq for |char|: 'a -> bool {
#[inline]
fn matches(&self, c: char) -> bool { (*self)(c) }
pub struct TaskBuilder {
/// Options to spawn the new task with
pub opts: TaskOpts,
- gen_body: Option<proc:Send(v: proc:Send()) -> proc:Send()>,
+ gen_body: Option<proc(v: proc():Send):Send -> proc():Send>,
nocopy: Option<marker::NoCopy>,
}
* existing body generator to the new body generator.
*/
pub fn with_wrapper(mut self,
- wrapper: proc:Send(v: proc:Send()) -> proc:Send())
+ wrapper: proc(v: proc():Send):Send -> proc():Send)
-> TaskBuilder
{
self.gen_body = match self.gen_body.take() {
* the provided unique closure. The task has the properties and behavior
* specified by the task_builder.
*/
- pub fn spawn(mut self, f: proc:Send()) {
+ pub fn spawn(mut self, f: proc():Send) {
let gen_body = self.gen_body.take();
let f = match gen_body {
Some(gen) => gen(f),
* # Failure
* Fails if a future_result was already set for this task.
*/
- pub fn try<T:Send>(mut self, f: proc:Send() -> T) -> Result<T, ~Any:Send> {
+ pub fn try<T:Send>(mut self, f: proc():Send -> T) -> Result<T, ~Any:Send> {
let (tx, rx) = channel();
let result = self.future_result();
/// the provided unique closure.
///
/// This function is equivalent to `task().spawn(f)`.
-pub fn spawn(f: proc:Send()) {
+pub fn spawn(f: proc():Send) {
let task = task();
task.spawn(f)
}
-pub fn try<T:Send>(f: proc:Send() -> T) -> Result<T, ~Any:Send> {
+pub fn try<T:Send>(f: proc():Send -> T) -> Result<T, ~Any:Send> {
/*!
* Execute a function in another task and return either the return value
* of the function or result::err.
fn test_with_wrapper() {
let (tx, rx) = channel();
task().with_wrapper(proc(body) {
- let result: proc:Send() = proc() {
+ let result: proc():Send = proc() {
body();
tx.send(());
};
}
#[cfg(test)]
-fn avoid_copying_the_body(spawnfn: |v: proc:Send()|) {
+fn avoid_copying_the_body(spawnfn: |v: proc():Send|) {
let (tx, rx) = channel::<uint>();
let x = ~1;
// (well, it would if the constant were 8000+ - I lowered it to be more
// valgrind-friendly. try this at home, instead..!)
static generations: uint = 16;
- fn child_no(x: uint) -> proc:Send() {
+ fn child_no(x: uint) -> proc():Send {
return proc() {
if x < generations {
task().spawn(child_no(x+1));
fn finally(&self, dtor: ||) -> T;
}
-impl<'a,T> Finally<T> for 'a || -> T {
+impl<'a,T> Finally<T> for ||: 'a -> T {
fn finally(&self, dtor: ||) -> T {
try_finally(&mut (), (),
|_, _| (*self)(),
struct Finallyalizer<'a,A> {
mutate: &'a mut A,
- dtor: 'a |&mut A|
+ dtor: |&mut A|: 'a
}
#[unsafe_destructor]
The executing thread has no access to a task pointer and will be using
a normal large stack.
*/
-pub fn run_in_bare_thread(f: proc:Send()) {
+pub fn run_in_bare_thread(f: proc():Send) {
use rt::thread::Thread;
Thread::start(f).join()
}
assert_eq!(v, three)
}
+ #[test]
fn test_grow_fn() {
let mut v = Vec::from_slice([0u, 1]);
v.grow_fn(3, |i| i);
}
enum FutureState<A> {
- Pending(proc:Send() -> A),
+ Pending(proc():Send -> A),
Evaluating,
Forced(A)
}
Future {state: Forced(val)}
}
- pub fn from_fn(f: proc
:Send() -> A) -> Future<A> {
+ pub fn from_fn(f: proc
():Send -> A) -> Future<A> {
/*!
* Create a future from a function.
*
})
}
- pub fn spawn(blk: proc
:Send() -> A) -> Future<A> {
+ pub fn spawn(blk: proc
():Send -> A) -> Future<A> {
/*!
* Create a future from a unique closure.
*
use std::task;
enum Msg<T> {
- Execute(proc:Send(&T)),
+ Execute(proc(&T):Send),
Quit
}
/// returns a function which, given the index of the task, should return
/// local data to be kept around in that task.
pub fn new(n_tasks: uint,
- init_fn_factory: || -> proc:Send(uint) -> T)
+ init_fn_factory: || -> proc(uint):Send -> T)
-> TaskPool<T> {
assert!(n_tasks >= 1);
/// Executes the function `f` on a task in the pool. The function
/// receives a reference to the local data returned by the `init_fn`.
- pub fn execute(&mut self, f: proc:Send(&T)) {
+ pub fn execute(&mut self, f: proc(&T):Send) {
self.channels.get(self.next_index).send(Execute(f));
self.next_index += 1;
if self.next_index == self.channels.len() { self.next_index = 0; }
#[test]
fn test_task_pool() {
- let f: || -> proc:Send(uint) -> uint = || {
- let g: proc:Send(uint) -> uint = proc(i) i;
+ let f: || -> proc(uint):Send -> uint = || {
+ let g: proc(uint):Send -> uint = proc(i) i;
g
};
let mut pool = TaskPool::new(4, f);
}
struct EachViewItemData<'a> {
- callback: 'a |&ast::ViewItem| -> bool,
+ callback: |&ast::ViewItem|: 'a -> bool,
}
impl<'a> Visitor<()> for EachViewItemData<'a> {
all the fields of all the structures, see above for details.
*/
pub type CombineSubstructureFunc<'a> =
- 'a |&mut ExtCtxt, Span, &Substructure| -> @Expr;
+ |&mut ExtCtxt, Span, &Substructure|: 'a -> @Expr;
/**
Deal with non-matching enum variants, the arguments are a list
[variant fields]), and a list of the nonself args of the type
*/
pub type EnumNonMatchFunc<'a> =
- 'a |&mut ExtCtxt,
+ |&mut ExtCtxt,
Span,
&[(uint, P<ast::Variant>, Vec<(Span, Option<Ident>, @Expr)> )],
- &[@Expr]|
+ &[@Expr]|: 'a
-> @Expr;
*/
- // NOTE: remove after the next stage0 snap
- let (decl, lifetimes, bounds) = if self.token == token::COLON {
- let (_, bounds) = self.parse_optional_ty_param_bounds(false);
- let (decl, lifetimes) = self.parse_ty_fn_decl(false);
- (decl, lifetimes, bounds)
+ let lifetimes = if self.eat(&token::LT) {
+ let lifetimes = self.parse_lifetimes();
+ self.expect_gt();
+ lifetimes
} else {
- let lifetimes = if self.eat(&token::LT) {
- let lifetimes = self.parse_lifetimes();
- self.expect_gt();
- lifetimes
- } else {
- Vec::new()
- };
-
- let (inputs, variadic) = self.parse_fn_args(false, false);
- let (_, bounds) = self.parse_optional_ty_param_bounds(false);
- let (ret_style, ret_ty) = self.parse_ret_ty();
- let decl = P(FnDecl {
- inputs: inputs,
- output: ret_ty,
- cf: ret_style,
- variadic: variadic
- });
- (decl, lifetimes, bounds)
+ Vec::new()
};
+
+ let (inputs, variadic) = self.parse_fn_args(false, false);
+ let (_, bounds) = self.parse_optional_ty_param_bounds(false);
+ let (ret_style, ret_ty) = self.parse_ret_ty();
+ let decl = P(FnDecl {
+ inputs: inputs,
+ output: ret_ty,
+ cf: ret_style,
+ variadic: variadic
+ });
TyClosure(@ClosureTy {
sigil: OwnedSigil,
region: None,
*/
- // NOTE: remove 'let region' after a stage0 snap
- let region = self.parse_opt_lifetime();
let purity = self.parse_unsafety();
let onceness = if self.eat_keyword(keywords::Once) {Once} else {Many};
inputs
};
- let (new_region, bounds) = self.parse_optional_ty_param_bounds(true);
-
- // NOTE: this should be removed after a stage0 snap
- let region = new_region.or(region);
+ let (region, bounds) = self.parse_optional_ty_param_bounds(true);
let (return_style, output) = self.parse_ret_ty();
let decl = P(FnDecl {
} else if self.token_is_closure_keyword() ||
self.token == token::BINOP(token::OR) ||
self.token == token::OROR ||
- self.token == token::LT ||
- // NOTE: remove this clause after a stage0 snap
- Parser::token_is_lifetime(&self.token) {
+ self.token == token::LT {
// CLOSURE
//
// FIXME(pcwalton): Eventually `token::LT` will not unambiguously
StaticTestFn(fn()),
StaticBenchFn(fn(&mut BenchHarness)),
StaticMetricFn(proc(&mut MetricMap)),
- DynTestFn(proc:Send()),
+ DynTestFn(proc():Send),
DynMetricFn(proc(&mut MetricMap)),
DynBenchFn(~TDynBenchFn)
}
#[allow(deprecated_owned_vector)]
fn run_test_inner(desc: TestDesc,
monitor_ch: Sender<MonitorMsg>,
- testfn: proc:Send()) {
+ testfn: proc():Send) {
spawn(proc() {
let (tx, rx) = channel();
let mut reader = ChanReader::new(rx);
pub fn exec<'a, T:Send +
Encodable<json::Encoder<'a>, io::IoError> +
Decodable<json::Decoder, json::Error>>(
- &'a self, blk: proc:Send(&mut Exec) -> T) -> T {
+ &'a self, blk: proc(&mut Exec):Send -> T) -> T {
self.exec_work(blk).unwrap()
}
fn exec_work<'a, T:Send +
Encodable<json::Encoder<'a>, io::IoError> +
Decodable<json::Decoder, json::Error>>( // FIXME(#5121)
- &'a self, blk: proc:Send(&mut Exec) -> T) -> Work<'a, T> {
+ &'a self, blk: proc(&mut Exec):Send -> T) -> Work<'a, T> {
let mut bo = Some(blk);
debug!("exec_work: looking up {} and {:?}", self.fn_name,
+S 2014-04-07 c7fac44
+ freebsd-x86_64 3c01e2a52a1487c360a8e075df0d4fd412d84fe9
+ linux-i386 145f83ec557db77160a207aa2a17e2db8e254b84
+ linux-x86_64 647d2922311a497280d49e91e4946a271d44a232
+ macos-i386 fa19ebca45f83e224911bad13475e40d531e6515
+ macos-x86_64 c0b4df5eed015c527a2a23ca3f2755a44782f61d
+ winnt-i386 e93af6e5ce88e1220f8b4b4cce14436af0b4279a
+
S 2014-04-03 e7fe207
freebsd-x86_64 6d40f547d13896ab9d9dd4a4fdf2e72be553b01b
linux-i386 875a8f6956f7d703f7206db91ca2a9b67c244cf8
// part of issue-6919.rs
struct C<'a> {
- pub k: 'a ||,
+ pub k: ||: 'a,
}
fn no_op() { }
// except according to those terms.
struct X {
- field: 'static ||:Send,
+ field: ||:'static + Send,
}
-fn foo(blk: 'static ||:) -> X {
- return X { field: blk }; //~ ERROR expected bounds `Send` but found no bounds
+fn foo(blk: ||:'static) -> X {
+ return X { field: blk }; //~ ERROR expected bounds `'static+Send`
}
fn main() {
fn id<T>(t: T) -> T { t }
-fn f<'r, T>(v: &'r T) -> 'r || -> T {
+fn f<'r, T>(v: &'r T) -> ||: 'r -> T {
id(|| *v) //~ ERROR cannot infer
}
fn foopy() {}
-static f: 'static || = foopy; //~ ERROR found extern fn
+static f: ||: 'static = foopy; //~ ERROR found extern fn
fn main () {
f();
fn main() {
let x = @3u;
- let _: proc:Send() = proc() foo(x); //~ ERROR does not fulfill `Send`
- let _: proc:Send() = proc() foo(x); //~ ERROR does not fulfill `Send`
- let _: proc:Send() = proc() foo(x); //~ ERROR does not fulfill `Send`
+ let _: proc():Send = proc() foo(x); //~ ERROR does not fulfill `Send`
+ let _: proc():Send = proc() foo(x); //~ ERROR does not fulfill `Send`
+ let _: proc():Send = proc() foo(x); //~ ERROR does not fulfill `Send`
let _: proc() = proc() foo(x);
}
// This struct is needed to create the
// otherwise infinite type of a fn that
// accepts itself as argument:
- c: 'a |&R, bool|
+ c: |&R, bool|: 'a
}
fn innocent_looking_victim() {
fn is_static<T: 'static>() {}
fn main() {
- is_send::<proc:()>();
+ is_send::<proc()>();
//~^ ERROR: instantiating a type parameter with an incompatible type
- is_freeze::<proc:()>();
+ is_freeze::<proc()>();
//~^ ERROR: instantiating a type parameter with an incompatible type
- is_static::<proc:()>();
+ is_static::<proc()>();
//~^ ERROR: instantiating a type parameter with an incompatible type
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn env<'a>(_: &'a uint, blk: |p: 'a |||) {
+fn env<'a>(_: &'a uint, blk: |p: ||: 'a|) {
// Test that the closure here cannot be assigned
// the lifetime `'a`, which outlives the current
// block.
blk(|| *statep = 1); //~ ERROR cannot infer
}
-fn no_env_no_for<'a>(_: &'a uint, blk: |p: 'a |||) {
+fn no_env_no_for<'a>(_: &'a uint, blk: |p: |||: 'a) {
// Test that a closure with no free variables CAN
// outlive the block in which it is created.
//
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn wants_static_fn(_x: 'static ||) {}
+fn wants_static_fn(_x: ||: 'static) {}
fn main() {
let i = 3;
// except according to those terms.
struct parameterized1<'a> {
- g: 'a ||
+ g: ||: 'a
}
struct not_parameterized1 {
- g: 'static ||
+ g: ||: 'static
}
struct not_parameterized2 {
- g: 'static ||
+ g: ||: 'static
}
fn take1(p: parameterized1) -> parameterized1 { p }
#![feature(managed_boxes)]
struct invariant<'a> {
- f: 'static |x: &mut &'a int|
+ f: |x: &mut &'a int|: 'static
}
fn to_same_lifetime<'r>(bi: invariant<'r>) {
#![feature(managed_boxes)]
struct invariant<'a> {
- f: 'static || -> &mut &'a int
+ f: ||: 'static -> &mut &'a int
}
fn to_same_lifetime<'r>(bi: invariant<'r>) {
struct indirect1 {
// Here the lifetime parameter of direct is bound by the fn()
- g: 'static |direct|
+ g: |direct|: 'static
}
struct indirect2<'a> {
// But here it is set to 'a
- g: 'static |direct<'a>|
+ g: |direct<'a>|: 'static
}
fn take_direct(p: direct) -> direct { p } //~ ERROR mismatched types
// except according to those terms.
struct closure_box<'a> {
- cl: 'a ||
+ cl: ||: 'a
}
-fn box_it<'r>(x: 'r ||) -> closure_box<'r> {
+fn box_it<'r>(x: ||: 'r) -> closure_box<'r> {
closure_box {cl: x}
}
pos_callback: Option<WindowPosCallback<'a>>,
}
-pub type WindowPosCallback<'a> = 'a |&Window, i32, i32|;
+pub type WindowPosCallback<'a> = |&Window, i32, i32|: 'a;
fn main() {
let x = WindowCallbacks { pos_callback: None };
fn main() {
let y = ~0;
- let x: @proc:Send() = @(proc() {
+ let x: @proc():Send = @(proc() {
println!("{:?}", y.clone());
});
failfn();
let cheese = ~"roquefort";
let carrots = @~"crunchy";
- let result: 'static |@~str, |~str|| = (|tasties, macerate| {
+ let result: |@~str, |~str||: 'static = (|tasties, macerate| {
macerate((*tasties).clone());
});
result(carrots, |food| {
pub fn main() {
let z = ~Pair { a : 10, b : 12};
- let f: proc:Send() = proc() {
+ let f: proc():Send = proc() {
assert_eq!(z.a, 10);
assert_eq!(z.b, 12);
};
foo::<proc<'a>(int, f32, &'a int):'static + Share -> &'a int>();
// issue #11209
- let _: 'b ||; // for comparison
+ let _: ||: 'b; // for comparison
let _: <'a> ||;
let _: Option<||:'b>;
let _: Option< <'a>||>;
// issue #11210
- let _: 'static ||;
+ let _: ||: 'static;
}
pub fn main() {
// except according to those terms.
pub fn main() {
- let early_error: 'static |&str| -> ! = |_msg| { fail!() };
+ let early_error: |&str|: 'static -> ! = |_msg| { fail!() };
}
static generations: uint = 1024+256+128+49;
-fn spawn(f: proc:Send()) {
+fn spawn(f: proc():Send) {
let mut t = task::task();
t.opts.stack_size = Some(32 * 1024);
t.spawn(f);
}
-fn child_no(x: uint) -> proc:Send() {
+fn child_no(x: uint) -> proc():Send {
proc() {
if x < generations {
spawn(child_no(x+1));
use std::task;
type RingBuffer = Vec<f64> ;
-type SamplesFn = proc:Send(samples: &RingBuffer);
+type SamplesFn = proc(samples: &RingBuffer):Send;
enum Msg
{
struct A { a: ~int }
-fn foo() -> 'static || -> int {
+fn foo() -> ||: 'static -> int {
let k = ~22;
let _u = A {a: k.clone()};
- let result: 'static || -> int = || 22;
+ let result: ||: 'static -> int = || 22;
result
}
pub fn main() {
foo::<proc()>();
- foo::<proc:()>();
- foo::<proc:Send()>();
- foo::<proc:Send + Share()>();
- foo::<proc:'static + Send + Share()>();
+ foo::<proc()>();
+ foo::<proc():Send>();
+ foo::<proc():Send + Share>();
+ foo::<proc():'static + Send + Share>();
- is_send::<proc:Send()>();
- is_freeze::<proc:Share()>();
- is_static::<proc:'static()>();
+ is_send::<proc():Send>();
+ is_freeze::<proc():Share>();
+ is_static::<proc():'static>();
let a = 3;
- bar::<proc:()>(proc() {
+ bar::<proc():>(proc() {
let b = &a;
println!("{}", *b);
});
fn test05() {
let three = ~3;
- let fn_to_send: proc:Send(int) = proc(n) {
+ let fn_to_send: proc(int):Send = proc(n) {
println!("{}", *three + n); // will copy x into the closure
assert_eq!(*three, 3);
};
fn test_rm_tempdir() {
let (tx, rx) = channel();
- let f: proc:Send() = proc() {
+ let f: proc():Send = proc() {
let tmp = TempDir::new("test_rm_tempdir").unwrap();
tx.send(tmp.path().clone());
fail!("fail to unwind past `tmp`");
let tmp = TempDir::new("test_rm_tempdir").unwrap();
let path = tmp.path().clone();
- let f: proc:Send() = proc() {
+ let f: proc():Send = proc() {
let _tmp = tmp;
fail!("fail to unwind past `tmp`");
};
struct Pointy {
a : maybe_pointy,
- d : proc:Send() -> uint,
+ d : proc():Send -> uint,
}
-fn make_uniq_closure<A:Send>(a: A) -> proc:Send() -> uint {
+fn make_uniq_closure<A:Send>(a: A) -> proc():Send -> uint {
proc() { &a as *A as uint }
}
struct Pointy {
a : maybe_pointy,
c : ~int,
- d : proc:Send()->(),
+ d : proc():Send->(),
}
fn empty_pointy() -> @RefCell<Pointy> {
projects / rust.git / commitdiff