// except according to those terms.
#![crate_type = "bin"]
-#![feature(phase)]
+#![feature(phase, slicing_syntax)]
#![deny(warnings)]
Within the body of an item that has type parameter declarations, the names of
its type parameters are types:
-```
+```ignore
fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
if xs.len() == 0 {
return vec![];
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
+#![allow(unknown_features)]
#![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
-#![feature(unsafe_destructor, import_shadowing)]
+#![feature(unsafe_destructor, import_shadowing, slicing_syntax)]
#![no_std]
#[phase(plugin, link)] extern crate core;
//! interval `[a, b)`:
//!
//! ```rust
-//! let numbers = [0i, 1i, 2i];
-//! let last_numbers = numbers[1..3];
-//! // last_numbers is now &[1i, 2i]
+//! #![feature(slicing_syntax)]
+//! fn main() {
+//! let numbers = [0i, 1i, 2i];
+//! let last_numbers = numbers[1..3];
+//! // last_numbers is now &[1i, 2i]
+//! }
//! ```
//!
//! ## Implementations of other traits
if i > 0 {
unsafe {
- res.as_mut_vec().push_all(v.[..i])
+ res.as_mut_vec().push_all(v[..i])
};
}
macro_rules! error(() => ({
unsafe {
if subseqidx != i_ {
- res.as_mut_vec().push_all(vv[subseqidx..i_]);
+ res.as_mut_vec().push_all(v[subseqidx..i_]);
}
subseqidx = i;
res.as_mut_vec().push_all(REPLACEMENT);
html_playground_url = "http://play.rust-lang.org/")]
#![no_std]
+#![allow(unknown_features)]
#![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
-#![feature(simd, unsafe_destructor)]
+#![feature(simd, unsafe_destructor, slicing_syntax)]
#![deny(missing_doc)]
mod macros;
* A trivial implementation of `Slice`. When `Foo[..Foo]` happens, it ends up
* calling `slice_to`, and therefore, `main` prints `Slicing!`.
*
- * ```
+ * ```ignore
* struct Foo;
*
* impl ::core::ops::Slice<Foo, Foo> for Foo {
* A trivial implementation of `SliceMut`. When `Foo[Foo..]` happens, it ends up
* calling `slice_from_mut`, and therefore, `main` prints `Slicing!`.
*
- * ```
+ * ```ignore
* struct Foo;
*
* impl ::core::ops::SliceMut<Foo, Foo> for Foo {
* }
* }
*
- * fn main() {
+ * pub fn main() {
* Foo[mut Foo..];
* }
* ```
#[inline]
fn tail_mut(self) -> &'a mut [T] {
let len = self.len();
- self.slice_mut(1, len)
+ self[mut 1..len]
}
#[inline]
fn init_mut(self) -> &'a mut [T] {
let len = self.len();
- self.slice_mut(0, len - 1)
+ self[mut 0..len - 1]
}
#[inline]
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(globs, unsafe_destructor, macro_rules)]
+#![feature(globs, unsafe_destructor, macro_rules, slicing_syntax)]
extern crate core;
extern crate test;
#![deny(unused_result, unused_must_use)]
#![allow(non_camel_case_types, deprecated)]
-#![feature(default_type_params, lang_items)]
+#![allow(unknown_features)]
+#![feature(default_type_params, lang_items, slicing_syntax)]
// NB this crate explicitly does *not* allow glob imports, please seriously
// consider whether they're needed before adding that feature here (the
//!
//! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
-#![feature(macro_rules)]
+#![allow(unknown_features)]
+#![feature(macro_rules, slicing_syntax)]
#![feature(default_type_params)]
#![crate_name = "num"]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, phase, slicing_syntax)]
#![allow(missing_doc)]
extern crate serialize;
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, phase, slicing_syntax)]
#![deny(missing_doc)]
#[cfg(test)]
html_root_url = "http://doc.rust-lang.org/master/")]
#![allow(deprecated)]
+#![allow(unknown_features)]
#![feature(macro_rules, globs, struct_variant, quote)]
-#![feature(default_type_params, phase, unsafe_destructor)]
+#![feature(default_type_params, phase, unsafe_destructor, slicing_syntax)]
#![feature(rustc_diagnostic_macros)]
#![feature(import_shadowing)]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/")]
-#![feature(globs, phase, macro_rules)]
+#![allow(unknown_features)]
+#![feature(globs, phase, macro_rules, slicing_syntax)]
#[phase(plugin, link)]
extern crate log;
#![crate_type = "dylib"]
#![crate_type = "rlib"]
-#![feature(globs, struct_variant, managed_boxes, macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(globs, struct_variant, managed_boxes, macro_rules, phase, slicing_syntax)]
extern crate arena;
extern crate debug;
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/")]
+#![allow(unknown_features)]
#![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
#![feature(linkage, lang_items, unsafe_destructor, default_type_params)]
-#![feature(import_shadowing)]
+#![feature(import_shadowing, slicing_syntax)]
#![no_std]
#![experimental]
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, managed_boxes, default_type_params, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, managed_boxes, default_type_params, phase, slicing_syntax)]
// test harness access
#[cfg(test)]
///
/// ```rust,no_run
/// # #![allow(unused_must_use)]
+/// #![feature(slicing_syntax)]
+///
/// use std::io::net::udp::UdpSocket;
/// use std::io::net::ip::{Ipv4Addr, SocketAddr};
+/// fn main() {
+/// let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 34254 };
+/// let mut socket = match UdpSocket::bind(addr) {
+/// Ok(s) => s,
+/// Err(e) => fail!("couldn't bind socket: {}", e),
+/// };
///
-/// let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 34254 };
-/// let mut socket = match UdpSocket::bind(addr) {
-/// Ok(s) => s,
-/// Err(e) => fail!("couldn't bind socket: {}", e),
-/// };
-///
-/// let mut buf = [0, ..10];
-/// match socket.recv_from(buf) {
-/// Ok((amt, src)) => {
-/// // Send a reply to the socket we received data from
-/// let buf = buf[mut ..amt];
-/// buf.reverse();
-/// socket.send_to(buf, src);
+/// let mut buf = [0, ..10];
+/// match socket.recv_from(buf) {
+/// Ok((amt, src)) => {
+/// // Send a reply to the socket we received data from
+/// let buf = buf[mut ..amt];
+/// buf.reverse();
+/// socket.send_to(buf, src);
+/// }
+/// Err(e) => println!("couldn't receive a datagram: {}", e)
/// }
-/// Err(e) => println!("couldn't receive a datagram: {}", e)
+/// drop(socket); // close the socket
/// }
-/// drop(socket); // close the socket
/// ```
pub struct UdpSocket {
obj: Box<RtioUdpSocket + Send>,
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
+#![allow(unknown_features)]
#![feature(macro_rules, globs, managed_boxes, linkage)]
#![feature(default_type_params, phase, lang_items, unsafe_destructor)]
-#![feature(import_shadowing)]
+#![feature(import_shadowing, slicing_syntax)]
// Don't link to std. We are std.
#![no_std]
("tuple_indexing", Active),
("associated_types", Active),
("visible_private_types", Active),
+ ("slicing_syntax", Active),
("if_let", Active),
self.gate_feature("if_let", e.span,
"`if let` syntax is experimental");
}
+ ast::ExprSlice(..) => {
+ self.gate_feature("slicing_syntax",
+ e.span,
+ "slicing syntax is experimental");
+ }
_ => {}
}
visit::walk_expr(self, e);
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/")]
-#![feature(macro_rules, globs, default_type_params, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, globs, default_type_params, phase, slicing_syntax)]
#![feature(quote, struct_variant, unsafe_destructor, import_shadowing)]
#![allow(deprecated)]
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, phase, slicing_syntax)]
#![deny(missing_doc)]
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
+#![feature(slicing_syntax)]
+
use std::{cmp, iter, mem};
use std::sync::Future;
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
+#![feature(slicing_syntax)]
+
use std::cmp::min;
use std::io::{stdout, IoResult};
use std::os;
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
+#![feature(slicing_syntax)]
+
use std::io;
use std::io::{BufferedWriter, File};
use std::cmp::min;
// multi tasking k-nucleotide
+#![feature(slicing_syntax)]
+
extern crate collections;
use std::collections::HashMap;
// ignore-android see #10393 #13206
+#![feature(slicing_syntax)]
+
use std::string::String;
use std::slice;
use std::sync::{Arc, Future};
// ignore-stage1
// ignore-cross-compile #12102
-#![feature(macro_rules, phase)]
+#![feature(macro_rules, phase, slicing_syntax)]
extern crate regex;
#[phase(plugin)]extern crate regex_macros;
// ignore-pretty very bad with line comments
// ignore-android doesn't terminate?
+#![feature(slicing_syntax)]
+
use std::iter::range_step;
use std::io::{stdin, stdout, File};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slicing_syntax)]
+
fn main() {
let mut array = [1, 2, 3];
//~^ ERROR cannot determine a type for this local variable: cannot determine the type of this integ
// Test that slicing syntax gives errors if we have not implemented the trait.
+#![feature(slicing_syntax)]
+
struct Foo;
fn main() {
// Test slicing expressions doesn't defeat the borrow checker.
+#![feature(slicing_syntax)]
+
fn main() {
let y;
{
// Test mutability and slicing syntax.
+#![feature(slicing_syntax)]
+
fn main() {
let x: &[int] = &[1, 2, 3, 4, 5];
// Can't mutably slice an immutable slice
// Test mutability and slicing syntax.
+#![feature(slicing_syntax)]
+
fn main() {
let x: &[int] = &[1, 2, 3, 4, 5];
// Immutable slices are not mutable.
// lldb-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }]
#![allow(unused_variable)]
+#![feature(slicing_syntax)]
struct AStruct {
x: i16,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slicing_syntax)]
+
fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
v[1..5]
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slicing_syntax)]
+
fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v[i..j] }
pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slicing_syntax)]
extern crate debug;
// Test slicing expressions on slices and Vecs.
+#![feature(slicing_syntax)]
+
fn main() {
let x: &[int] = &[1, 2, 3, 4, 5];
let cmp: &[int] = &[1, 2, 3, 4, 5];
// Test that is a slicing expr[..] fails, the correct cleanups happen.
+#![feature(slicing_syntax)]
+
use std::task;
struct Foo;
// Test that is a slicing expr[..] fails, the correct cleanups happen.
+#![feature(slicing_syntax)]
+
use std::task;
struct Foo;
// Test slicing sugar.
+#![feature(slicing_syntax)]
+
extern crate core;
use core::ops::{Slice,SliceMut};
projects / rust.git / commitdiff