return RawT {struct_: st, cname: cname, hash: 0u};
}
-fn main() { mk_raw_ty(ty_nil, None::<~str>); }
+pub fn main() { mk_raw_ty(ty_nil, None::<~str>); }
fn@() -> (A, u16) { (a, b) }
}
-fn main() {
+pub fn main() {
let (a, b) = f(22_u64, 44u16)();
debug!("a=%? b=%?", a, b);
assert a == 22u64;
fn@() -> (A, B) { (a, b) }
}
-fn main() {
+pub fn main() {
let x = 22_u8;
let y = 44_u64;
let z = f(~x, y);
fn f<T>() -> ~[T] { return ~[]; }
-fn main() { let r: R<int> = R {mut v: ~[]}; r.v = f(); }
+pub fn main() { let r: R<int> = R {mut v: ~[]}; r.v = f(); }
}
}
-fn main() {
+pub fn main() {
f1(@"a");
f1(~"b");
f1(&"c");
// n.b. This was only ever failing with optimization disabled.
fn a() -> int { match return 1 { 2 => 3, _ => die!() } }
-fn main() { a(); }
+pub fn main() { a(); }
// except according to those terms.
-fn main() {
+pub fn main() {
let i: int =
match Some::<int>(3) { None::<int> => { die!() } Some::<int>(_) => { 5 } };
log(debug, i);
struct Pair { mut a: ~int, mut b: ~int }
-fn main() {
+pub fn main() {
let x = ~Pair {mut a: ~10, b: ~20};
match x {
~Pair {a: ref mut a, b: ref b} => {
return;
}
-fn main() { debug!("hello"); foo::<int>(Some::<int>(5)); }
+pub fn main() { debug!("hello"); foo::<int>(Some::<int>(5)); }
struct X { x: int }
-fn main() {
+pub fn main() {
let x = match 0 {
_ => X {
x: 0
struct X { x: int }
-fn main() {
+pub fn main() {
let x = match 0 {
_ => X {
x: 0
fn bar(x: m1::foo) { match x { m1::foo1 => { } m1::foo2 => { } } }
-fn main() { }
+pub fn main() { }
let _ = ::core::sys::refcount(s); // don't get bitten by last-use.
}
-fn main() {
+pub fn main() {
let s: @int = @0; // ref up
let count = ::core::sys::refcount(s);
}
}
-fn main() { assert (altlit(10) == 20); assert (altlit(11) == 22); }
+pub fn main() { assert (altlit(10) == 20); assert (altlit(11) == 22); }
match x { nothing => { error!("A"); } just(a) => { error!("B"); } }
}
-fn main() { }
+pub fn main() { }
fn altsimple(f: int) { match f { x => () } }
-fn main() { }
+pub fn main() { }
fn foo(it: fn(int)) { it(10); }
-fn main() {
+pub fn main() {
let mut x = true;
match a {
a => { x = true; foo(|_i| { } ) }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
match 5u {
1u..5u => {}
_ => die!(~"should match range"),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = Some(private::exclusive(true));
match move x {
Some(ref z) if z.with(|b| *b) => {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut v = Some(22);
match v {
None => {}
}
}
-fn main() {
+pub fn main() {
let mut v = Rec {f: 22};
destructure(&mut v);
assert v.f == 23;
}
}
-fn main() {
+pub fn main() {
assert destructure(Some(22)) == 22;
}
// Issue #53
-fn main() {
+pub fn main() {
match ~"test" { ~"not-test" => die!(), ~"test" => (), _ => die!() }
enum t { tag1(~str), tag2, }
return x;
}
-fn main() {
+pub fn main() {
let gray: color = rgb(127, 127, 127);
let clear: color = rgba(50, 150, 250, 0);
let red: color = hsl(0, 255, 255);
}
}
-fn main() {
+pub fn main() {
altsimple(5);
altsimple("asdfasdfsDF");
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
match ~100 {
~x => {
debug!("%?", x);
}
}
-fn main() {
+pub fn main() {
foo(Some(~22), true);
foo(Some(~22), false);
foo(None, true);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
// sometimes we have had trouble finding
// the right type for f, as we unified
// bot and u32 here
use anonexternmod::*;
-fn main() {
+pub fn main() {
last_os_error();
}
fn last_os_error() -> ~str;
}
-fn main() {
+pub fn main() {
unsafe {
let _ = last_os_error();
}
}
}
-fn main() {
+pub fn main() {
let x = Foo::new();
io::println(x.x.to_str());
}
extern mod anon_trait_static_method_lib;
use anon_trait_static_method_lib::Foo;
-fn main() {
+pub fn main() {
let x = Foo::new();
io::println(x.x.to_str());
}
fn f2(a: int, f: fn(int)) -> int { f(1); return a; }
-fn main() {
+pub fn main() {
let mut a = X {mut x: 1}, b = 2, c = 3;
assert (f1(a, &mut b, move c) == 6);
assert (a.x == 0);
-fn main() {
+pub fn main() {
let a: int = 10;
log(debug, a);
assert (a * (a - 1) == 90);
-fn main() {
+pub fn main() {
let i32_a: int = 10;
assert (i32_a == 10);
assert (i32_a - 10 == 0);
-fn main() {
+pub fn main() {
let i32_c: int = 0x10101010;
assert (i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3));
// Unsigned integer operations
-fn main() {
+pub fn main() {
assert (0u8 < 255u8);
assert (0u8 <= 255u8);
assert (255u8 > 0u8);
fn f() -> int { { return 3; } }
-fn main() { assert (f() == 3); }
+pub fn main() { assert (f() == 3); }
assert (x == 33);
}
-fn main() { test_assign(); test_assign_op(); }
+pub fn main() { test_assign(); test_assign_op(); }
return len;
}
-fn main() {
+pub fn main() {
let x = ~[0,1,2,3];
// Call a method
for x.iterate() |y| { assert x[*y] == *y; }
#[foo = "bar"]
extern mod std;
-fn main() {
+pub fn main() {
}
extern mod std;
}
-fn main() {
+pub fn main() {
}
// xfail-fast
-fn main() {
+pub fn main() {
die!()
}
#[auto_decode]
enum CLike { A, B, C }
-fn main() {
+pub fn main() {
let a = &Plus(@Minus(@Val(3u), @Val(10u)), @Plus(@Val(22u), @Val(5u)));
test_prettyprint(a, &~"Plus(@Minus(@Val(3u), @Val(10u)), \
@Plus(@Val(22u), @Val(5u)))");
fn f<T: Copy, U: Copy>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
-fn main() {
+pub fn main() {
log(debug, f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
log(debug, f(5, 6).a);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut sum = 0;
for vec::each(~[1, 2, 3, 4, 5]) |x| {
sum += *x;
}
}
-fn main() {
+pub fn main() {
let y = Bar { x: 42 };
y.f();
}
fn len(&self) -> uint { **self }
}
-fn main() {
+pub fn main() {
let m = Foo(3);
assert m.len() == 3;
}
pure fn test_const(&const self) { assert *self == "test" }
}
-fn main() {
+pub fn main() {
// NB: Associativity of ~, etc. in this context is surprising. These must be parenthesized
([1]).test_imm();
}
}
-fn main() {
+pub fn main() {
let mut v = ~[1];
v.push_val(2);
v.push_val(3);
}
}
-fn main() {
+pub fn main() {
let x = Foo { x: 3 };
x.printme();
}
fn g(act: fn(~[int]) -> int) -> int { return act(~[1, 2, 3]); }
-fn main() {
+pub fn main() {
assert (g(f) == 1);
let f1: fn(~[~str]) -> ~str = f;
assert (f1(~[~"x", ~"y", ~"z"]) == ~"x");
x.f();
}
-fn main() {
+pub fn main() {
}
enum foo = uint;
-fn main() {
+pub fn main() {
let x = foo(3u);
assert x.double() == 6u;
}
assert x.double() == exp;
}
-fn main() {
+pub fn main() {
let x = @(3u as double);
is_equal(x, 6);
}
fn double() -> uint { self * 2u }
}
-fn main() {
+pub fn main() {
let x = @(3u as double);
assert x.double() == 6u;
}
fn double() -> uint { *self * 2u }
}
-fn main() {
+pub fn main() {
let x = @3u;
assert x.double() == 6u;
}
fn double() -> uint { **self * 2u }
}
-fn main() {
+pub fn main() {
let x = @@@@@3u;
assert x.double() == 6u;
}
fn double() -> uint { self * 2u }
}
-fn main() {
+pub fn main() {
let x = @@3u;
assert x.double() == 6u;
}
fn double() -> uint { self * 2u }
}
-fn main() {
+pub fn main() {
let x = @3u;
assert x.double() == 6u;
}
}
}
-fn main() {
+pub fn main() {
let x = @3u;
assert x.foo() == ~"@3";
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x: &static/str = "foo";
io::println(x);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
assert 0xffffffffu32 == (-1 as u32);
assert 4294967295u32 == (-1 as u32);
assert 0xffffffffffffffffu64 == (-1 as u64);
// Check that issue #954 stays fixed
-fn main() {
+pub fn main() {
match -1 { -1 => {}, _ => die!(~"wat") }
assert 1-1 == 0;
}
use std::arc;
fn dispose(+_x: arc::ARC<bool>) unsafe { }
-fn main() {
+pub fn main() {
let p = arc::arc(true);
let x = Some(p);
match move x {
assert(q != r);
}
-fn main() {
+pub fn main() {
test_nil();
test_bool();
test_char();
true
}
-fn main() {
+pub fn main() {
do iter::repeat(10000) || {bitv_test()};
}
assert (0b1010_1010 | 0b0101_0101 == 0xff);
}
-fn main() {
+pub fn main() {
general();
target();
}
return f();
}
-fn main() {
+pub fn main() {
let x = asSendfn(|| 22u);
assert(x == 22u);
let x = asLambda(|| 22u);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let v = ~[-1f, 0f, 1f, 2f, 3f];
// Trailing expressions don't require parentheses:
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
fn f(i: fn() -> uint) -> uint { i() }
let v = ~[-1f, 0f, 1f, 2f, 3f];
let z = do do vec::foldl(f, v) |x, _y| { x } { 22u };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
fn f(i: uint) -> uint { i }
let v = ~[-1f, 0f, 1f, 2f, 3f];
let z = do vec::foldl(f, v) |x, _y| { x } (22u);
return do vec::foldl(0, v) |x,y| { x+*y } - 10;
}
-fn main() {
+pub fn main() {
assert w_semi(~[0, 1, 2, 3]) == -10;
assert w_paren1(~[0, 1, 2, 3]) == -4;
assert w_paren2(~[0, 1, 2, 3]) == -4;
return f();
}
-fn main() {
+pub fn main() {
let x_r = do call_any { 22u };
assert x_r == 22u;
}
return f;
}
-fn main() {
+pub fn main() {
let x: fn@(uint) -> uint = to_lambda(|x| x * 2u );
let y = to_lambda(x);
// except according to those terms.
// Check usage and precedence of block arguments in expressions:
-fn main() {
+pub fn main() {
let v = ~[-1f, 0f, 1f, 2f, 3f];
// Statement form does not require parentheses:
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
fn as_buf<T>(s: ~str, f: fn(~str) -> T) -> T { f(s) }
as_buf(~"foo", |foo: ~str| -> () log(error, foo) );
}
*
*/
-fn main() {
+pub fn main() {
let num = 12;
// except according to those terms.
fn force(f: fn() -> int) -> int { return f(); }
-fn main() {
+pub fn main() {
fn f() -> int { return 7; }
assert (force(f) == 7);
let g = {||force(f)};
fn iter_vec<T>(v: ~[T], f: fn(T)) { for v.each |x| { f(*x); } }
-fn main() {
+pub fn main() {
let v = ~[1, 2, 3, 4, 5, 6, 7];
let mut odds = 0;
iter_vec(v, |i| {
fn iter_vec<T>(v: ~[T], f: fn(T)) { for v.each |x| { f(*x); } }
-fn main() {
+pub fn main() {
let v = ~[1, 2, 3, 4, 5];
let mut sum = 0;
iter_vec(copy v, |i| {
extern mod std;
-fn main() {
+pub fn main() {
let v =
vec::map2(~[1, 2, 3, 4, 5],
~[true, false, false, true, true],
// -*- rust -*-
-fn main() {
+pub fn main() {
if !false { assert (true); } else { assert (false); }
if !true { assert (false); } else { assert (true); }
}
fn foo(self) {}
}
-fn main() {
+pub fn main() {
let items = ~[ 3, 5, 1, 2, 4 ];
items.foo();
}
fn impure(_v: &[int]) {
}
-fn main() {
+pub fn main() {
let x = F {f: ~[3]};
match x {
return sum;
}
-fn main() {
+pub fn main() {
let x = @[1, 2, 3];
assert sum_slice(x) == 6;
}
\ No newline at end of file
}
}
-fn main() {
+pub fn main() {
test1(@~22);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = [22];
let y = &x[0];
assert *y == 22;
borrow(v);
}
-fn main() {
+pub fn main() {
}
}
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
uint::range(0, l, |i| f(&x.values[i]))
}
-fn main() {
+pub fn main() {
let mut ints = ~Ints {sum: ~0, values: ~[]};
add_int(ints, 22);
add_int(ints, 44);
want_slice(v)
}
-fn main() {
+pub fn main() {
assert has_mut_vec(~[mut 1, 2, 3]) == 6;
}
\ No newline at end of file
bar.baz = 3;
}
-fn main() {}
+pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut x = None;
match x {
None => {
// exec-env:RUST_POISON_ON_FREE=1
-fn main() {
+pub fn main() {
let x: @mut @Option<~int> = @mut @None;
match x {
@@Some(ref y) => {
struct F { f: ~int }
-fn main() {
+pub fn main() {
let mut x = @F {f: ~3};
match x {
@F {f: ref b_x} => {
struct F { f: ~int }
-fn main() {
+pub fn main() {
let mut x = @F {f: ~3};
do borrow(x.f) |b_x| {
assert *b_x == 3;
struct F { f: ~int }
-fn main() {
+pub fn main() {
let mut x = @mut @F {f: ~3};
match x {
@@F{f: ref b_x} => {
struct F { f: ~int }
-fn main() {
+pub fn main() {
let mut x = ~mut @F{f: ~3};
do borrow(x.f) |b_x| {
assert *b_x == 3;
}
}
-fn main() {
+pub fn main() {
switcher(None);
switcher(Some(@3));
}
\ No newline at end of file
assert before == after;
}
-fn main() {
+pub fn main() {
let mut x = @3;
do borrow(x) |b_x| {
assert *b_x == 3;
assert *r == exp;
}
-fn main() {
+pub fn main() {
testfn(true);
testfn(false);
}
\ No newline at end of file
struct F { f: ~int }
-fn main() {
+pub fn main() {
let mut x = @F {f: ~3};
do borrow((*x).f) |b_x| {
assert *b_x == 3;
struct F { mut f: @G }
struct G { g: ~[int] }
-fn main() {
+pub fn main() {
let rec = @F {mut f: @G {g: ~[1, 2, 3]}};
while rec.f.g.len() == 23 {}
}
struct Rec { mut f: @int }
-fn main() {
+pub fn main() {
let rec = @Rec {mut f: @22};
while *borrow(rec.f) == 23 {}
}
newtype(int)
}
-fn main() {
+pub fn main() {
// Test that borrowck treats enums with a single variant
// specially.
bar(&*cat);
}
-fn main() {
+pub fn main() {
let mut mimi = ~Cat;
foo(mimi);
}
}
}
-fn main() {
+pub fn main() {
let mut harry = Wizard {
spells: ~[ "expelliarmus", "expecto patronum", "incendio" ]
};
g(&*x);
}
-fn main() {
+pub fn main() {
let mut x = ~Some(3);
f(x);
}
io::println(x.to_str());
}
-fn main() {
+pub fn main() {
let x = @mut 3;
f(x);
}
}
}
-fn main() {
+pub fn main() {
assert foo(&~"kitty");
assert !foo(&~"gata");
}
}
}
-fn main() {
+pub fn main() {
assert foo(&3);
assert !foo(&4);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let (&x, &y, &z) = (&3, &'a', &@"No pets!");
assert x == 3;
assert y == 'a';
}
}
-fn main() {
+pub fn main() {
let x = None;
let y = Some(3);
assert select(&x, &y).get() == 3;
}
}
-fn main() {
+pub fn main() {
assert foo(&3) == 3;
assert foo(&'a') == 'a';
assert foo(&@"Dogs rule, cats drool") == @"Dogs rule, cats drool";
fn ignore<T>(_x: T) {}
-fn main() {
+pub fn main() {
let f: fn@:Owned() = ||();
ignore(f);
}
-fn main() {
+pub fn main() {
assert (@1 < @3);
assert (@@~"hello " > @@~"hello");
assert (@@@~"hello" != @@@~"there");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let i: (@int, int) = (@10, 10); let (a, _) = i; }
+pub fn main() { let i: (@int, int) = (@10, 10); let (a, _) = i; }
if is_odd(n) && length_is_even(some_box(1)) { error!("bloop"); }
}
-fn main() { foo(67, 5); }
+pub fn main() { foo(67, 5); }
if is_odd(n) || length_is_even(some_box(1)) { error!("bloop"); }
}
-fn main() { foo(67, 5); }
+pub fn main() { foo(67, 5); }
struct Foo {a: int, b: uint}
enum bar { u(@Foo), w(int), }
-fn main() {
+pub fn main() {
assert (match u(@Foo{a: 10, b: 40u}) {
u(@Foo{a: a, b: b}) => { a + (b as int) }
_ => { 66 }
fn unbox<T: Copy>(b: Box<T>) -> T { return *b.c; }
-fn main() {
+pub fn main() {
let foo: int = 17;
let bfoo: Box<int> = Box {c: @foo};
debug!("see what's in our box");
-fn main() { let x: @int = @10; assert (*x == 10); }
+pub fn main() { let x: @int = @10; assert (*x == 10); }
mut box: Option<@Box>
};
-fn main() { }
+pub fn main() { }
}
}
-fn main() {
+pub fn main() {
let x = 3 as @Foo;
x.foo();
}
fn int_id(x: int) -> int { return x; }
-fn main() { loop { int_id(break); } }
+pub fn main() { loop { int_id(break); } }
-fn main() {
+pub fn main() {
let mut i = 0;
while i < 20 { i += 1; if i == 10 { break; } }
assert (i == 10);
fn free<T>(-_t: T) {
}
-fn main() {
+pub fn main() {
let z = @3;
assert 3 == it_takes_two(z, z);
}
pub fn get_task_id() -> libc::intptr_t;
}
-fn main() {
+pub fn main() {
unsafe {
let _foo = rustrt::get_task_id;
}
return str::as_buf(s, { |x, _len| unsafe { libc::atoll(x) } });
}
-fn main() {
+pub fn main() {
unsafe {
assert atol(~"1024") * 10 == atol(~"10240");
assert (atoll(~"11111111111111111") * 10i64)
fn foo() -> int { 22 }
-fn main() {
+pub fn main() {
let x = dvec::DVec::<@fn() -> int>();
x.push(foo);
assert (x[0])() == 22;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = ~1;
let y = ptr::addr_of(&(*x)) as uint;
let lam_move = fn@(move x) -> uint { ptr::addr_of(&(*x)) as uint };
// except according to those terms.
// error-pattern: warning: Captured variable 'y' not used in closure
-fn main() {
+pub fn main() {
let x = 5;
let _y = fn~(copy x) { };
}
p
}
-fn main() {
+pub fn main() {
foo(()).recv()
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = 3;
debug!("&x=%x", ptr::to_uint(&x));
}
\ No newline at end of file
// -*- rust -*-
-fn main() {
+pub fn main() {
let i: int = 'Q' as int;
assert (i == 0x51);
let u: u32 = i as u32;
extern mod cci_impl_lib;
use cci_impl_lib::uint_helpers;
-fn main() {
+pub fn main() {
//let bt0 = sys::frame_address();
//debug!("%?", bt0);
extern mod cci_iter_lib;
-fn main() {
+pub fn main() {
//let bt0 = sys::rusti::frame_address(1u32);
//debug!("%?", bt0);
do cci_iter_lib::iter(~[1, 2, 3]) |i| {
// except according to those terms.
#[cfg(windows)]
-fn main() {
+pub fn main() {
}
#[cfg(unix)]
-fn main() {
+pub fn main() {
}
\ No newline at end of file
// except according to those terms.
#[cfg(target_family = "windows")]
-fn main() {
+pub fn main() {
}
#[cfg(target_family = "unix")]
-fn main() {
+pub fn main() {
}
\ No newline at end of file
-fn main() {
+pub fn main() {
let c: char = 'x';
let d: char = 'x';
assert (c == 'x');
fn child2(&&s: ~str) { }
-fn main() { let x = task::spawn(|| child2(~"hi") ); }
+pub fn main() { let x = task::spawn(|| child2(~"hi") ); }
#[cat_maker]
fn cat(name: ~str) -> cat { cat{name: name,} }
-fn main() { let _kitty = cat(~"Spotty"); }
+pub fn main() { let _kitty = cat(~"Spotty"); }
}
}
-fn main() {
+pub fn main() {
let _kitty = cat(~"Spotty");
}
assert(actual == expected);
}
-fn main() {
+pub fn main() {
let nyan : ToStr = cat(0u, 2, ~"nyan") as ToStr;
print_out(nyan, ~"nyan");
}
assert(actual == expected);
}
-fn main() {
+pub fn main() {
let nyan : to_str = cat(0u, 2, "nyan") as to_str;
print_out(nyan, "nyan");
}
for uint::range(0u, 10u) |i| { critter.speak(); }
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(0u, 2, ~"nyan");
let whitefang : dog = dog();
annoy_neighbors((copy nyan) as noisy);
}
-fn main() {
+pub fn main() {
let nyan : noisy = cat(0u, 2, ~"nyan") as noisy;
nyan.speak();
}
\ No newline at end of file
}
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {
+pub fn main() {
assert(cat(~"Spreckles").get_name() == ~"Spreckles");
}
fn clear() { }
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(0, 2, "nyan");
for uint::range(1u, 5u) |_i| { nyan.speak(); }
// cat returns true if uint input is greater than
}
}
-fn main() {
+pub fn main() {
let nyan : cat<~str> = cat(0, 2, ~"nyan");
for uint::range(1u, 5u) |_i| { nyan.speak(); }
assert(nyan.find(1) == Some(~"nyan"));
}
-fn main() {
+pub fn main() {
let nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert(!nyan.eat());
c.speak();
}
-fn main() {
+pub fn main() {
let nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert(!nyan.eat());
option::is_some(critter.scratch())
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(0u, 2, "nyan");
annoy_neighbors(nyan as noisy);
assert(nyan.meow_count() == 10u);
extern mod cci_class_2;
use cci_class_2::kitties::*;
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
let kitty = cat(1000u, 2);
assert(nyan.how_hungry == 99);
extern mod cci_class_3;
use cci_class_3::kitties::*;
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
let kitty = cat(1000u, 2);
assert(nyan.how_hungry == 99);
}
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
let kitty = cat(1000u, 2);
assert(nyan.how_hungry == 99);
extern mod cci_class_6;
use cci_class_6::kitties::*;
-fn main() {
+pub fn main() {
let nyan : cat<char> = cat::<char>(52u, 99, ~['p']);
let kitty = cat(1000u, 2, ~[~"tabby"]);
assert(nyan.how_hungry == 99);
}
}
-fn main() {
+pub fn main() {
let nyan : cat<int> = cat::<int>(52u, 99, ~[9]);
let kitty = cat(1000u, 2, ~[~"tabby"]);
assert(nyan.how_hungry == 99);
assert(actual == expected);
}
-fn main() {
+pub fn main() {
let nyan : ToStr = cat(0u, 2, ~"nyan") as ToStr;
print_out(nyan, ~"nyan");
}
}
}
-fn main() {
+pub fn main() {
let nyan = cat(~"nyan");
}
\ No newline at end of file
fn eachi(blk: fn(uint, K) -> bool) { iter::eachi(self, blk) }
}
-fn main() {
+pub fn main() {
let m = int_hash();
m.insert(1, 2);
m.insert(3, 4);
}
-fn main() {
+pub fn main() {
let _nyan : cat<int> = cat::<int>(52u, 99);
// let kitty = cat(1000u, 2);
}
extern mod cci_class_4;
use cci_class_4::kitties::*;
-fn main() {
+pub fn main() {
let nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert(!nyan.eat());
type cat = @kitten;
-fn main() {}
+pub fn main() {}
extern mod cci_class;
use cci_class::kitties::*;
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
let kitty = cat(1000u, 2);
assert(nyan.how_hungry == 99);
}
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
let kitty = cat(1000u, 2);
assert(nyan.how_hungry == 99);
}
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
let kitty = cat(1000u, 2);
assert(nyan.how_hungry == 99);
}
}
-fn main() {
+pub fn main() {
let nyan = cat(0u, 2, ~"nyan");
nyan.eat();
assert(!nyan.eat());
// xfail-win32
fn adder(+x: @int, +y: @int) -> int { return *x + *y; }
fn failer() -> @int { die!(); }
-fn main() {
+pub fn main() {
assert(result::is_err(&task::try(|| {
adder(@2, failer()); ()
})));
assert (x.b == 12);
}
-fn main() {
+pub fn main() {
let z : @{a:int, b:int} = @{ a : 10, b : 12};
let p = task::_spawn(bind f(z));
task::join_id(p);
fn@() -> (A, u16) { (a, b) }
}
-fn main() {
+pub fn main() {
let (a, b) = f(22_u64, 44u16)();
debug!("a=%? b=%?", a, b);
assert a == 22u64;
fn apply<A>(f: fn(A) -> A, v: A) -> A { f(v) }
-fn main() {
+pub fn main() {
let f = {|i| foo(i)};
assert apply(f, 2) == 3;
}
// Test a rather underspecified example:
-fn main() {
+pub fn main() {
let f = {|i| i};
assert f(2) == 2;
assert f(5) == 5;
negate(y)
}
-fn main() {}
+pub fn main() {}
speaker.how_many() + 33
}
-fn main() {
+pub fn main() {
let mut lincoln = SpeechMaker {speeches: 22};
assert foo(&const lincoln) == 55;
}
sum(y)
}
-fn main() {}
\ No newline at end of file
+pub fn main() {}
\ No newline at end of file
v.to_vec()
}
-fn main() {
+pub fn main() {
let mut the_vec = ~[1, 2, 3, 100];
assert the_vec == foo(the_vec);
assert the_vec == bar(the_vec);
talk(speaker);
}
-fn main() {
+pub fn main() {
let mut lincoln = SpeechMaker {speeches: 22};
give_a_few_speeches(&mut lincoln);
}
speaker.talk();
}
-fn main() {
+pub fn main() {
let mut lincoln = SpeechMaker {speeches: 22};
give_a_few_speeches(&mut lincoln);
}
vec::reverse(v);
}
-fn main() {
+pub fn main() {
let mut the_vec = ~[1, 2, 3, 100];
bar(the_vec);
assert the_vec == ~[100, 3, 2, 1];
v.reverse();
}
-fn main() {
+pub fn main() {
let mut the_vec = ~[1, 2, 3, 100];
bar(the_vec);
assert the_vec == ~[100, 3, 2, 1];
impl S : X {}
-fn main(){}
+pub fn main(){}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
enum x { foo }
impl x : ::core::cmp::Eq {
pure fn eq(&self, other: &x) -> bool {
use core::pipes::*;
-fn main() {
+pub fn main() {
let (p, ch) = stream();
let t = task::spawn(|| child(&ch) );
let y = p.recv();
Baz(int)
}
-fn main() {
+pub fn main() {
let x = Bar(3);
}
x == y
}
-fn main() {
+pub fn main() {
assert !cmp(Some(3), None);
assert !cmp(Some(3), Some(4));
assert cmp(Some(3), Some(3));
return 0;
}
-fn main() {
+pub fn main() {
let x: int = 2 + 2;
log(debug, x);
debug!("hello, world");
// except according to those terms.
#[cfg(target_arch = "x86")]
-fn main() { }
+pub fn main() { }
#[cfg(target_arch = "x86_64")]
-fn main() { }
+pub fn main() { }
// Since the bogus configuration isn't defined main will just be
// parsed, but nothing further will be done with it
#[cfg(bogus)]
-fn main() { die!() }
+pub fn main() { die!() }
-fn main() {
+pub fn main() {
// Exercise some of the configured items in ways that wouldn't be possible
// if they had the bogus definition
assert (b);
const X: Foo = Baz;
-fn main() {
+pub fn main() {
match X {
Baz => {}
_ => die!()
struct F { field: int }
-fn main() {
+pub fn main() {
foo(1);
foo(~"hi");
foo(~[1, 2, 3]);
const a: int = 1;
const b: int = a + 2;
-fn main() {
+pub fn main() {
assert b == 3;
}
\ No newline at end of file
const notb : bool = !true;
const neg : int = -(1);
-fn main() {
+pub fn main() {
assert(lsl == 4);
assert(add == 3);
assert(addf == 3.0f);
}
}
-fn main() {
+pub fn main() {
C.method()
}
}
}
-fn main() {
+pub fn main() {
f(&C)
}
f: *u8
}
-fn main() {
+pub fn main() {
assert foopy == f;
assert f == s.f;
}
\ No newline at end of file
e: 40}};
const m : int = k.c.e;
-fn main() {
+pub fn main() {
io::println(fmt!("%?", p));
io::println(fmt!("%?", q));
io::println(fmt!("%?", t));
const b : Bar = Bar { f: foo };
-fn main() {
+pub fn main() {
assert (b.f)() == 0xca7f000d;
}
\ No newline at end of file
const toplevel_mod: int = -1;
-fn main() {
+pub fn main() {
assert toplevel_mod == -1;
}
\ No newline at end of file
const X: Foo = Foo(17);
-fn main() {
+pub fn main() {
assert(*X == 17);
assert(*Y == 23);
}
const X: Foo = Bar;
-fn main() {
+pub fn main() {
match X {
Bar => {}
Baz | Boo => die!()
const X: Foo = Bar;
-fn main() {
+pub fn main() {
assert((X as uint) == 0xDEADBEE);
assert((Y as uint) == 0xDEADBEE);
}
y: Pair { a: 3.14159265358979323846,
b: 2.7182818284590452354 }};
-fn main() {
+pub fn main() {
let (p, _) = y.x;
assert p == 0xf0f0f0f0_f0f0f0f0;
io::println(fmt!("0x%x", p as uint));
const y: &Pair = &Pair {a: 15, b: x};
-fn main() {
+pub fn main() {
io::println(fmt!("x = %?", *x));
io::println(fmt!("y = {a: %?, b: %?}", y.a, *(y.b)));
assert *x == 10;
const y : foo = foo { b:2, c:3, a: 1 };
const z : &foo = &foo { a: 10, b: 22, c: 12 };
-fn main() {
+pub fn main() {
assert x.b == 2;
assert x == y;
assert z.b == 22;
const X: Bar = Bar(1, 2);
-fn main() {
+pub fn main() {
match X {
Bar(x, y) => {
assert x == 1;
const X: Foo = Foo;
-fn main() {
+pub fn main() {
match X {
Foo => {}
}
const x : [int * 4] = [1,2,3,4];
const y : &[int] = &[1,2,3,4];
-fn main() {
+pub fn main() {
io::println(fmt!("%?", x[1]));
io::println(fmt!("%?", y[1]));
assert x[1] == 2;
const i: int = 10;
-fn main() { log(debug, i); }
+pub fn main() { log(debug, i); }
const FOO: int = 10;
const BAR: int = 3;
-fn main() {
+pub fn main() {
let x: int = 3;
let y = match x {
FOO => 1,
// Regression test that f64 exports things properly
-fn main() {
+pub fn main() {
let digits: uint = 10 as uint;
extern mod crate_method_reexport_grrrrrrr2;
-fn main() {
+pub fn main() {
use crate_method_reexport_grrrrrrr2::rust::add;
use crate_method_reexport_grrrrrrr2::rust::cx;
let x = @();
extern mod crateresolve1(vers = "0.2");
-fn main() {
+pub fn main() {
assert crateresolve1::f() == 20;
}
pub fn f() { assert crateresolve2::f() == 30; }
}
-fn main() {
+pub fn main() {
a::f();
b::f();
c::f();
pub fn f() { assert crateresolve3::g() == 20; }
}
-fn main() {
+pub fn main() {
a::f();
b::f();
}
extern mod cr5_1 (name = "crateresolve5", vers = "0.1");
extern mod cr5_2 (name = "crateresolve5", vers = "0.2");
-fn main() {
+pub fn main() {
// Structural types can be used between two versions of the same crate
assert cr5_1::struct_nameval().name == cr5_2::struct_nameval().name;
assert cr5_1::struct_nameval().val == cr5_2::struct_nameval().val;
extern mod cr6_1 (name = "crateresolve_calories", vers = "0.1", calories="100");
extern mod cr6_2 (name = "crateresolve_calories", vers = "0.1", calories="200");
-fn main() {
+pub fn main() {
assert cr6_1::f() == 100;
assert cr6_2::f() == 200;
}
extern mod crateresolve7x;
-fn main() {
+pub fn main() {
assert crateresolve7x::a::f() == 100;
assert crateresolve7x::b::f() == 200;
}
*box = cons(box);
}
-fn main() {
+pub fn main() {
f();
}
fn nop() { }
fn nop_foo(_x : @foo) { }
-fn main() {
+pub fn main() {
let w = @foo{ mut z: || nop() };
let x : fn@() = || nop_foo(w);
w.z = x;
fn nop() { }
fn nop_foo(_y: ~[int], _x : @foo) { }
-fn main() {
+pub fn main() {
let w = @foo{ z: || nop() };
let x : fn@() = || nop_foo(~[], w);
w.z = x;
fn o() -> @int { @10 }
-fn main() {
+pub fn main() {
let w = @foo { mut z: || nop() };
let x : fn@() = || nop_foo(o(), w);
w.z = x;
// -*- rust -*-
-fn main() { if 1 == 1 { return; } debug!("Paul is dead"); }
+pub fn main() { if 1 == 1 { return; } debug!("Paul is dead"); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let _x = ~[
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = ~[
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
if x == 1 { return 1; } else { let y: int = 1 + f(x - 1); return y; }
}
-fn main() { assert (f(5000) == 5000); }
+pub fn main() { assert (f(5000) == 5000); }
}
}
-fn main() {
+pub fn main() {
let a = A { x: 1 };
a.f();
}
-fn main() { let x = @mut 5; *x = 1000; log(debug, *x); }
+pub fn main() { let x = @mut 5; *x = 1000; log(debug, *x); }
-fn main() { let x: @int = @10; let y: int = *x; }
+pub fn main() { let x: @int = @10; let y: int = *x; }
TaskHandle(task_id)
}
-fn main() { }
+pub fn main() { }
Boo
}
-fn main() {
+pub fn main() {
let a = Bar;
let b = Bar;
assert a == b;
Baz(float, float)
}
-fn main() {
+pub fn main() {
let a = Bar(1, 2);
let b = Bar(1, 2);
assert a == b;
E
}
-fn main(){}
+pub fn main(){}
z: int
}
-fn main() {}
+pub fn main() {}
Y
}
-fn main() {
+pub fn main() {
let x = X { x: 1, y: 2 };
assert x == x;
assert !(x != x);
z: int,
}
-fn main() {
+pub fn main() {
let a = Foo { x: 1, y: 2, z: 3 };
let b = Foo { x: 1, y: 2, z: 3 };
assert a == b;
z: int
}
-fn main() {
+pub fn main() {
let a = Foo { x: 1, y: 2.0, z: 3 };
let b = Foo { x: 1, y: 2.0, z: 3 };
assert a == b;
let x: int = die!();
}
-fn main() {
+pub fn main() {
}
// -*- rust -*-
-fn main() {
+pub fn main() {
let x: int = 15;
let y: int = 5;
assert (x / 5 == 3);
fn f(f: fn() -> bool) {
}
-fn main() {
+pub fn main() {
do f() || { true }
do f() { true }
do f || { true }
fn d(f: fn@()) { }
-fn main() {
+pub fn main() {
for f { }
do d { }
}
\ No newline at end of file
do f { }
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
fn f(f: fn&(int)) { f(10) }
-fn main() {
+pub fn main() {
do f() |i| { assert i == 10 }
}
fn f(f: fn@(int)) { f(10) }
-fn main() {
+pub fn main() {
do f() |i| { assert i == 10 }
}
fn f(f: fn@(int) -> int) -> int { f(10) }
-fn main() {
+pub fn main() {
assert do f() |i| { i } == 10;
}
fn f(f: fn@(int) -> int) -> int { f(10) }
-fn main() {
+pub fn main() {
assert do f |i| { i } == 10;
}
fn g(i: int) { }
fn f(foo: @@quux) { g(foo.bar); }
-fn main() { }
+pub fn main() { }
enum t { foo(@int), }
-fn main() { let tt = foo(@10); match tt { foo(z) => { } } }
+pub fn main() { let tt = foo(@10); match tt { foo(z) => { } } }
// -*- rust -*-
fn f() -> int { if true { let s: ~str = ~"should not leak"; return 1; } return 0; }
-fn main() { f(); }
+pub fn main() { f(); }
}
}
-fn main() {
+pub fn main() {
let x = S { x: 1 };
}
}
}
-fn main() {
+pub fn main() {
let x: Foo = Foo { x: 3 };
}
use list = std::map::chained;
use std::list;
-fn main() {
+pub fn main() {
let _x: list::T<int, int> = list::mk();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = dvec::DVec();
x.push(1);
io::println(fmt!("%d", x[0]));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let d = dvec::DVec();
d.push(3);
d.push(4);
// except according to those terms.
fn wsucc(n: int) -> int { 0 + { return n + 1 } }
-fn main() { }
+pub fn main() { }
struct A { a: int }
-fn main() {
+pub fn main() {
for iter::eachi(&(Some(A {a: 0}))) |i, a| {
debug!("%u %d", i, a.a);
-fn main() {
+pub fn main() {
if 1 == 2 {
assert (false);
} else if 2 == 3 {
-fn main() { let v: ~[mut int] = ~[mut]; }
+pub fn main() { let v: ~[mut int] = ~[mut]; }
assert i == chan_t;
}
-fn main() {
+pub fn main() {
let wrapped = {||wrapper3(chan_t)};
wrapped();
}
enum color { red = 1, green, blue, imaginary = -1, }
-fn main() {
+pub fn main() {
test_color(red, 1, ~"red");
test_color(green, 2, ~"green");
test_color(blue, 3, ~"blue");
}
}
-fn main() {
+pub fn main() {
let x = a::Bar;
}
Cat { name: ~str, weight: float }
}
-fn main() {
+pub fn main() {
let mut a: Animal = Dog(~"Cocoa", 37.2);
a = Cat{ name: ~"Spotty", weight: 2.7 };
// permuting the fields should work too
// except according to those terms.
// xfail-test
-fn main() {
+pub fn main() {
let x : @str = @"hello";
}
// except according to those terms.
-fn main() {
+pub fn main() {
let x = &"hello";
let v = &"hello";
let mut y : &str = &"there";
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x : ~str = ~"hello";
let _y : ~str = ~"there";
let mut z = ~"thing";
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x : [@int * 5] = [@1,@2,@3,@4,@5];
let _y : [@int * 5] = [@1,@2,@3,@4,@5];
let mut z = [@1,@2,@3,@4,@5];
// Doesn't work; needs a design decision.
-fn main() {
+pub fn main() {
let x : [int * 5] = [1,2,3,4,5];
let _y : [int * 5] = [1,2,3,4,5];
let mut z = [1,2,3,4,5];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x : &[int] = &[1,2,3,4,5];
let mut z = &[1,2,3,4,5];
z = x;
// xfail-fast (exec-env not supported in fast mode)
// exec-env:TEST_EXEC_ENV=22
-fn main() {
+pub fn main() {
assert os::getenv(~"TEST_EXEC_ENV") == Some(~"22");
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x: int = 8i;
let y = 9i;
x + y;
}
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {
+pub fn main() {
let mut m = ~linear_map::<(),()>();
assert m.len() == 0;
}
}
}
-fn main() {
+pub fn main() {
let x = @S { x: 3 };
let y = x as @Foo;
y.f();
}
}
-fn main() {
+pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
x.read_bytes(0);
}
}
-fn main() {
+pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
x.read_bytes(0);
}
}
-fn main() {
+pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
x.read_bytes(0);
}
}
-fn main() {
+pub fn main() {
let x = S { x: 1, y: 2 };
let x = x as @Reader;
x.read_bytes(0);
}
}
-fn main() {
+pub fn main() {
let x = @S { x: 3 };
let y = x as @Foo;
y.f();
}
}
-fn main() {
+pub fn main() {
let x = ~S { x: 3 };
let y = x as ~Foo;
y.f();
trait Nus { fn f(&self); }
impl thing: Nus { fn f(&self) {} }
-fn main() {
+pub fn main() {
let x = @thing(A {mut a: @10});
assert x.foo() == 10;
extern mod explicit_self_xcrate;
use explicit_self_xcrate::{Foo, Bar};
-fn main() {
+pub fn main() {
let x = Bar { x: ~"hello" };
x.f();
}
pub fn f() -> t { return t1; }
}
-fn main() { let v: foo::t = foo::f(); }
+pub fn main() { let v: foo::t = foo::f(); }
}
}
-fn main() { }
+pub fn main() { }
pub fn g() { }
}
-fn main() { f(); g(); m::f(); m::g(); }
+pub fn main() { f(); g(); m::f(); m::g(); }
pub fn x() { debug!("x"); }
}
-fn main() { self::foo::bar::y(); }
+pub fn main() { self::foo::bar::y(); }
pub fn x() { debug!("x"); }
}
-fn main() { foo::x(); }
+pub fn main() { foo::x(); }
pub enum t { t1, }
}
-fn main() { let v = foo::t1; }
+pub fn main() { let v = foo::t1; }
pub fn g(v: t) { assert (v == t1); }
}
-fn main() { foo::g(foo::f()); }
+pub fn main() { foo::g(foo::f()); }
assert (res == ~"happy");
}
-fn main() { test_box(); test_str(); }
+pub fn main() { test_box(); test_str(); }
// When all branches of an match expression result in fail, the entire
// match expression results in fail.
-fn main() {
+pub fn main() {
let x =
match true {
true => { 10 }
assert (r[0] == 10);
}
-fn main() { test_simple(); test_box(); }
+pub fn main() { test_simple(); test_box(); }
test_generic::<bool>(@true, compare_box);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
test_generic::<@int>(@1, compare_box);
}
-fn main() { test_vec(); }
+pub fn main() { test_vec(); }
test_generic::<bool>(~true, compare_box);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
test_generic::<~int>(~1, compare_box);
}
-fn main() { test_vec(); }
+pub fn main() { test_vec(); }
test_generic::<Pair>(Pair {a: 1, b: 2}, compare_rec);
}
-fn main() { test_bool(); test_rec(); }
+pub fn main() { test_bool(); test_rec(); }
assert (rs == happy);
}
-fn main() { test_rec(); test_tag(); }
+pub fn main() { test_rec(); test_tag(); }
assert (*res == 100);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
assert (rs);
}
-fn main() {
+pub fn main() {
test_basic();
test_inferrence();
test_alt_as_alt_head();
// -*- rust -*-
-fn main() { let x = { @100 }; assert (*x == 100); }
+pub fn main() { let x = { @100 }; assert (*x == 100); }
//assert (rs() == 10);
}
-fn main() { test_fn(); }
+pub fn main() { test_fn(); }
test_generic::<bool>(@true, compare_box);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
test_generic::<@int>(@1, compare_vec);
}
-fn main() { test_vec(); }
+pub fn main() { test_vec(); }
test_generic::<bool>(~true, compare_box);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
test_generic::<~int>(~1, compare_vec);
}
-fn main() { test_vec(); }
+pub fn main() { test_vec(); }
test_generic::<Pair>(Pair {a: 1, b: 2}, compare_rec);
}
-fn main() { test_bool(); test_rec(); }
+pub fn main() { test_bool(); test_rec(); }
// except according to those terms.
// Regression test for issue #388
-fn main() { let x = { { @10 } }; }
+pub fn main() { let x = { { @10 } }; }
struct A { a: int }
struct V { v: int }
-fn main() {
+pub fn main() {
let a = { let b = A {a: 3}; b };
assert (a.a == 3);
let c = { let d = V {v: 3}; d };
// -*- rust -*-
-fn main() { let x = { ~100 }; assert (*x == 100); }
+pub fn main() { let x = { ~100 }; assert (*x == 100); }
assert (rs == 10);
}
-fn main() { test_basic(); test_rec(); test_filled_with_stuff(); }
+pub fn main() { test_basic(); test_rec(); test_filled_with_stuff(); }
struct A { mut a: int }
-fn main() {
+pub fn main() {
let x = A {a: 10};
f(x);
assert x.a == 100;
// Make sure we drop the refs of the temporaries needed to return the
// values from the else if branch
-fn main() {
+pub fn main() {
let y: @uint = @10u;
let x = if false { y } else if true { y } else { y };
assert (*y == 10u);
// except according to those terms.
// Regression test for issue #388
-fn main() { let x = if false { @0u } else if true { @10u } else { @0u }; }
+pub fn main() { let x = if false { @0u } else if true { @10u } else { @0u }; }
fn f() { let x = match true { true => { 10 } false => { return } }; }
-fn main() { }
+pub fn main() { }
fn test_nil() { () }
-fn main() {
+pub fn main() {
test_int();
test_vec();
test_generic();
assert (rs == ~"happy");
}
-fn main() { test_box(); test_str(); }
+pub fn main() { test_box(); test_str(); }
// When all branches of an if expression result in fail, the entire if
// expression results in fail.
-fn main() { let x = if true { 10 } else { if true { die!() } else { die!() } }; }
+pub fn main() { let x = if true { 10 } else { if true { die!() } else { die!() } }; }
assert (x == 10);
}
-fn main() { test_if_fail(); test_else_fail(); test_elseif_fail(); }
+pub fn main() { test_if_fail(); test_else_fail(); test_elseif_fail(); }
test_generic::<bool>(@true, @false, compare_box);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
test_generic::<@int>(@1, @2, compare_box);
}
-fn main() { test_vec(); }
+pub fn main() { test_vec(); }
test_generic::<Pair>(Pair{a: 1, b: 2}, Pair{a: 2, b: 3}, compare_rec);
}
-fn main() { test_bool(); test_rec(); }
+pub fn main() { test_bool(); test_rec(); }
assert (rs == happy);
}
-fn main() { test_rec(); test_tag(); }
+pub fn main() { test_rec(); test_tag(); }
assert (*rs == 100);
}
-fn main() { test_box(); }
+pub fn main() { test_box(); }
assert (rs);
}
-fn main() {
+pub fn main() {
test_if();
test_else();
test_elseif1();
// xfail-fast
pub fn f() { }
-fn main() { return ::f(); }
+pub fn main() { return ::f(); }
fn f(p: @Point) { assert (p.z == 12); p.z = 13; assert (p.z == 13); }
-fn main() {
+pub fn main() {
let a: Point = Point {x: 10, y: 11, mut z: 12};
let b: @Point = @copy a;
assert (b.z == 12);
extern fn f() {
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
}
}
-fn main() {
+pub fn main() {
let result = count(1000u);
debug!("result = %?", result);
assert result == 1000u;
}
}
-fn main() {
+pub fn main() {
// Make sure we're on a task with small Rust stacks (main currently
// has a large stack)
do task::spawn {
}
}
-fn main() {
+pub fn main() {
// Make sure we're on a task with small Rust stacks (main currently
// has a large stack)
do task::spawn {
}
}
-fn main() {
+pub fn main() {
let result = fact(10u);
debug!("result = %?", result);
assert result == 3628800u;
}
}
-fn main() {
+pub fn main() {
let result = fact(10u);
debug!("result = %?", result);
assert result == 3628800u;
fn pow(x: f64, y: f64) -> f64;
}
-fn main() {}
+pub fn main() {}
extern mod std;
use std::map::HashMap;
-fn main() {
+pub fn main() {
io::println("Hello world!");
}
++n: libc::size_t);
}
-fn main() {
+pub fn main() {
}
}
}
-fn main() {
+pub fn main() {
for iter::repeat(100u) {
do task::spawn {
assert count(5u) == 16u;
extern fn g() {
}
-fn main() {
+pub fn main() {
// extern functions are *u8 types
let a: *u8 = f;
let b: *u8 = f;
}
}
-fn main() {
+pub fn main() {
for iter::repeat(10u) {
do task::spawn {
let result = count(5u);
}
}
-fn main() {
+pub fn main() {
assert (f(5) == 120);
// debug!("all done");
blue
}
-fn main() {
+pub fn main() {
log(error, match red {
red => { 1 }
green => { 2 }
return if n == 0 { 1 } else { n * f(n - 1) };
}
-fn main() {
+pub fn main() {
let fact = fix(fact_);
assert (fact(5) == 120);
assert (fact(2) == 2);
return if n == 0 { 1 } else { n * f(n - 1) };
}
-fn main() {
+pub fn main() {
let fact = fix(fact_);
assert (fact(5) == 120);
assert (fact(2) == 2);
// error on implicit copies to check fixed length vectors
// are implicitly copyable
#[deny(implicit_copies)]
-fn main() {
+pub fn main() {
let arr = [1,2,3];
let arr2 = arr;
assert(arr[1] == 2);
struct Struc { a: u8, b: [int * 3], c: int }
-fn main() {
+pub fn main() {
let arr = [1,2,3];
let struc = Struc {a: 13u8, b: arr, c: 42};
let s = sys::log_str(&struc);
z: f64
}
-fn main() {
+pub fn main() {
let x: f32 = 4.0;
io::println(x.to_str());
let y: float = 64.0;
extern mod std;
-fn main() {
+pub fn main() {
let nan = float::NaN;
assert(float::is_NaN(nan));
-fn main() {
+pub fn main() {
fn foo(n: float) -> float { return n + 0.12345; }
let n: float = 0.1;
let m: float = foo(n);
-fn main() {
+pub fn main() {
let pi = 3.1415927;
log(debug, -pi * (pi + 2.0 / pi) - pi * 5.0);
if pi == 5.0 || pi < 10.0 || pi <= 2.0 || pi != 22.0 / 7.0 || pi >= 10.0
-fn main() {
+pub fn main() {
let a = 1.5e6;
let b = 1.5E6;
let c = 1e6;
-fn main() {
+pub fn main() {
let f = 4.999999999999;
assert (f > 4.90);
assert (f < 5.0);
fn@(m: int) -> int { m + n }
}
-fn main()
+pub fn main()
{
assert add(3)(4) == 7;
let add3 : fn(int)->int = add(3);
fn@(m: int) -> int { m + n }
}
-fn main()
+pub fn main()
{
assert add(3)(4) == 7;
f(10, called);
}
-fn main() {
+pub fn main() {
let mut called = false;
let h = f;
g(h, &mut called);
fn likes_block(f: fn()) { f() }
-fn main() {
+pub fn main() {
likes_block(bare);
}
\ No newline at end of file
fn likes_shared(f: fn@()) { f() }
-fn main() {
+pub fn main() {
likes_shared(bare);
}
\ No newline at end of file
debug!("This is a bare function");
}
-fn main() {
+pub fn main() {
f();
}
\ No newline at end of file
extern mod std;
-fn main() {
+pub fn main() {
// Bare functions should just be a pointer
assert sys::rustrt::size_of::<fn()>() ==
sys::rustrt::size_of::<int>();
assert i == 100;
}
-fn main() {
+pub fn main() {
spawn(100, f);
}
field: fn@()
}
-fn main() {
+pub fn main() {
fn f() {}
let i: r = r {field: f};
}
\ No newline at end of file
fn id(x: int) -> int { return x; }
-fn main() { foo(id); }
+pub fn main() { foo(id); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let v : &[(int,int)] = &[ (1, 2), (3, 4), (5, 6) ];
for v.each |&(x, y)| {
io::println(y.to_str());
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let f: fn((int,int)) = |(x, y)| {
assert x == 1;
assert y == 2;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
// We should be able to type infer inside of fn@s.
let f = fn@() { let i = 10; };
}
struct Pair { x: int, y: int }
-fn main() {
+pub fn main() {
for vec::each(~[Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) |elt| {
assert (elt.x + elt.y == 30);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let x: ~[int] = ~[]; for x.each |_i| { die!(~"moop"); } }
+pub fn main() { let x: ~[int] = ~[]; for x.each |_i| { die!(~"moop"); } }
// -*- rust -*-
fn two(it: fn(int)) { it(0); it(1); }
-fn main() {
+pub fn main() {
let a: ~[mut int] = ~[mut -1, -1, -1, -1];
let mut p: int = 0;
do two |i| {
while i < 10 { it((i, j)); i += 1; j += i; }
}
-fn main() {
+pub fn main() {
let mut i: int = 10;
let mut j: int = 0;
do pairs() |p| {
// -*- rust -*-
-fn main() {
+pub fn main() {
let mut sum: int = 0;
do first_ten |i| { debug!("main"); log(debug, i); sum = sum + i; }
debug!("sum");
pub fn last_os_error() -> ~str;
}
-fn main() {
+pub fn main() {
unsafe {
rustrt1::last_os_error();
rustrt2::last_os_error();
}
}
-fn main() {
+pub fn main() {
let len = strlen(~"Rust");
assert(len == 4u);
}
pub fn IDONTKNOW() -> u32;
}
-fn main() {
+pub fn main() {
assert IDONTKNOW() == 0x_BAD_DOOD_u32;
}
// -*- rust -*-
-fn main() {
+pub fn main() {
let f = "Makefile";
let s = rustrt.str_buf(f);
let buf = libc.malloc(1024);
pub const errno: int;
}
-fn main() {
+pub fn main() {
}
pub fn get_task_id() -> libc::intptr_t;
}
-fn main() {
+pub fn main() {
unsafe {
rustrt::get_task_id();
}
// -*- rust -*-
-fn main() {
+pub fn main() {
libc.puts(rustrt.str_buf("hello, extern world 1"));
libc.puts(rustrt.str_buf("hello, extern world 2"));
libc.puts(rustrt.str_buf("hello, extern world 3"));
pub fn printf(++v: void);
}
-fn main() { }
+pub fn main() { }
#[nolink]
extern mod baz {}
-fn main() { }
+pub fn main() { }
fn direct(x: int) -> int { return x + 1; }
-fn main() {
+pub fn main() {
let a: int = direct(3); // direct
let b: int = ho(direct); // indirect unbound
// -*- rust -*-
fn f() -> int { return 42; }
-fn main() {
+pub fn main() {
let g: extern fn() -> int = f;
let i: int = g();
assert (i == 42);
y: int
}
-fn main() {
+pub fn main() {
let a = Foo { x: 1, y: 2 };
let c = Foo { x: 4, .. a};
io::println(fmt!("%?", c));
fn id<T: Copy>(t: T) -> T { return t; }
-fn main() {
+pub fn main() {
let expected = @100;
let actual = id::<@int>(expected);
log(debug, *actual);
fn id<T: Copy Owned>(t: T) -> T { return t; }
-fn main() {
+pub fn main() {
let expected = ~100;
let actual = id::<~int>(copy expected);
log(debug, *actual);
struct Box<T> {x: T, y: T, z: T}
-fn main() {
+pub fn main() {
let x: @Box<int> = box::<int>(Box{x: 1, y: 2, z: 3});
assert (x.y == 2);
}
return g::<Pair<T>>(x);
}
-fn main() {
+pub fn main() {
let b = f::<int>(10);
log(debug, b.a);
log(debug, b.b);
fn f<T: Copy>(t: T) { let t1: T = t; }
-fn main() { let x = Pair {x: @10, y: @12}; f(x); }
+pub fn main() { let x = Pair {x: @10, y: @12}; f(x); }
fn reclift<T: Copy>(t: T) -> Recbox<T> { return Recbox {x: @t}; }
-fn main() {
+pub fn main() {
let foo: int = 17;
let rbfoo: Recbox<int> = reclift::<int>(foo);
assert (*rbfoo.x == foo);
fn reclift<T: Copy>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
-fn main() {
+pub fn main() {
let foo: int = 17;
let rbfoo: Recbox<int> = reclift::<int>(foo);
assert (*rbfoo.x == foo);
fn f<T>(x: @T) -> @T { return x; }
-fn main() { let x = f(@3); log(debug, *x); }
+pub fn main() { let x = f(@3); log(debug, *x); }
// Issue #45: infer type parameters in function applications
fn id<T: Copy>(x: T) -> T { return x; }
-fn main() { let x: int = 42; let y: int = id(x); assert (x == y); }
+pub fn main() { let x: int = 42; let y: int = id(x); assert (x == y); }
pub fn foo<T>() { }
}
-fn main() { foomod::foo::<int>(); foomod::foo::<int>(); }
+pub fn main() { foomod::foo::<int>(); foomod::foo::<int>(); }
fn f<T: Copy>(x: ~T) -> ~T { return x; }
-fn main() { let x = f(~3); log(debug, *x); }
+pub fn main() { let x = f(~3); log(debug, *x); }
struct Triple {x: int, y: int, z: int}
-fn main() {
+pub fn main() {
let mut x = 62;
let mut y = 63;
let a = 'a';
enum wrapper<T> { wrapped(T), }
-fn main() { let w = wrapped(~[1, 2, 3, 4, 5]); }
+pub fn main() { let w = wrapped(~[1, 2, 3, 4, 5]); }
// except according to those terms.
fn f<T>(v: @T) { }
-fn main() { f(@~[1, 2, 3, 4, 5]); }
+pub fn main() { f(@~[1, 2, 3, 4, 5]); }
struct S<T>(T);
-fn main() {
+pub fn main() {
let s = S(2i);
io::println(s.to_str());
}
}
}
-fn main() {
+pub fn main() {
let x = @S { x: 1 };
let y = x as @Foo<int>;
assert y.get() == 1;
enum list<T> { cons(@T, @list<T>), nil, }
-fn main() {
+pub fn main() {
let a: list<int> =
cons::<int>(@10, @cons::<int>(@12, @cons::<int>(@13, @nil::<int>)));
}
assert (hit);
}
-fn main() { altfoo::<int>(arm::<int>(10)); }
+pub fn main() { altfoo::<int>(arm::<int>(10)); }
// This causes memory corruption in stage0.
enum thing<K> { some(K), }
-fn main() { let x = some(~"hi"); }
+pub fn main() { let x = some(~"hi"); }
enum clam<T> { a(T), }
-fn main() { let c = a(3); }
+pub fn main() { let c = a(3); }
struct Pair { x: int, y: int }
-fn main() {
+pub fn main() {
let nop: noption<int> = some::<int>(5);
match nop { some::<int>(n) => { log(debug, n); assert (n == 5); } }
let nop2: noption<Pair> = some(Pair{x: 17, y: 42});
enum option<T> { some(@T), none, }
-fn main() { let mut a: option<int> = some::<int>(@10); a = none::<int>; }
+pub fn main() { let mut a: option<int> = some::<int>(@10); a = none::<int>; }
consume(produce());
}
-fn main() {
+pub fn main() {
let produce: extern fn() -> int = mk;
let consume: extern fn(&&v: int) = chk;
apply::<int>(produce, consume);
fn get_third<T: Copy>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
-fn main() {
+pub fn main() {
log(debug, get_third((1, 2, 3)));
assert (get_third((1, 2, 3)) == 3);
assert (get_third((5u8, 6u8, 7u8)) == 7u8);
fn takebar<T>(b: bar<T>) { }
-fn main() { }
+pub fn main() { }
struct Pair<T> {x: T, y: T}
-fn main() {
+pub fn main() {
let x: Pair<int> = Pair {x: 10, y: 12};
assert (x.x == 10);
assert (x.y == 12);
fn box<T: Copy>(x: Triple<T>) -> ~Triple<T> { return ~x; }
-fn main() {
+pub fn main() {
let x: ~Triple<int> = box::<int>(Triple{x: 1, y: 2, z: 3});
assert (x.y == 2);
}
use std::getopts::*;
-fn main() {
+pub fn main() {
let args = ~[];
let opts = ~[optopt(~"b")];
pub fn g() { assert (f() == 2); assert (::f() == 1); }
}
-fn main() { return foo::g(); }
+pub fn main() { return foo::g(); }
}
-fn main() {
+pub fn main() {
assert xyzzy(R(Some(5))) == 0;
}
struct Pair { x: int, y: int }
-fn main() {
+pub fn main() {
let a =
match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
assert (a == 2);
}
}
-fn main() {
+pub fn main() {
map_reduce::map_reduce(~[~"../src/test/run-pass/hashmap-memory.rs"]);
}
// except according to those terms.
-fn main() {
+pub fn main() {
io::println("hello, world");
}
( []; [:$e:expr]; ) => ( $e );
)
-fn main() {
+pub fn main() {
let page = html! (
<html>
<head><title>This is the title.</title></head>
// -*- rust -*-
-fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; assert (x == 400_i32); }
+pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; assert (x == 400_i32); }
// -*- rust -*-
-fn main() {
+pub fn main() {
let mut x: i8 = -12i8;
let y: i8 = -12i8;
x = x + 1i8;
-fn main() {
+pub fn main() {
let i: int = if false { die!() } else { 5 };
log(debug, i);
}
}
}
-fn main() { foo(2u); }
+pub fn main() { foo(2u); }
fn foo() { if (return) { } }
-fn main() { foo(); }
+pub fn main() { foo(); }
fn foo() -> bool { true }
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
fn foo() -> uint { vec::len(self) }
}
-fn main() {
+pub fn main() {
let v = ~[const 0];
assert v.foo() == 1u;
let v = ~[0];
pub use spam::{ham, eggs};
}
-fn main() { rustrt::ham(); rustrt::eggs(); }
+pub fn main() { rustrt::ham(); rustrt::eggs(); }
pub fn eggs() { }
}
-fn main() { ham(); eggs(); }
+pub fn main() { ham(); eggs(); }
}
-fn main() { f1(); f2(); f4(); nameless_fear(); also_redstone(); }
+pub fn main() { f1(); f2(); f4(); nameless_fear(); also_redstone(); }
extern mod std;
use core::vec::*;
-fn main() {
+pub fn main() {
let mut v = from_elem(0u, 0);
v = vec::append(v, ~[4, 2]);
assert (reversed(v) == ~[2, 4]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
use vec::cast_to_mut;
log(debug, vec::len(cast_to_mut(~[1, 2])));
{
}
}
-fn main() { baz(); quux(); }
+pub fn main() { baz(); quux(); }
pub fn thing() { x(10); z(10); }
}
-fn main() { bar::thing(); }
+pub fn main() { bar::thing(); }
pub fn bar() { debug!("bar"); }
}
-fn main() { bar(); }
+pub fn main() { bar(); }
}
}
-fn main() { bar(); }
+pub fn main() { bar(); }
pub fn bar() { debug!("bar"); }
}
-fn main() { let zed = 42; bar(); }
+pub fn main() { let zed = 42; bar(); }
}
}
-fn main() { bar(); }
+pub fn main() { bar(); }
mod bar {
pub use zed::baz;
}
-fn main() { baz(); }
+pub fn main() { baz(); }
pub mod zed {}
}
}
-fn main() { baz(); }
+pub fn main() { baz(); }
pub fn x(y: int) { log(debug, y); }
}
-fn main() { x(10); z(10); }
+pub fn main() { x(10); z(10); }
fn f() -> ~[int] { ~[] }
-fn main() { }
+pub fn main() { }
struct Rec { a: int, b: fn(Pair) -> int }
struct Pair { x: int, y: int }
-fn main() {
+pub fn main() {
eat_tup(~@(10, |a| a.x ));
eat_rec(@~Rec{a: 10, b: |a| a.x });
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = 2;
let x_message = match x {
0 .. 1 => { ~"not many" }
loop { }
}
-fn main() { let t: task = spawn loop(5); join(t); }
\ No newline at end of file
+pub fn main() { let t: task = spawn loop(5); join(t); }
\ No newline at end of file
assert *i == 1;
}
-fn main() {
+pub fn main() {
test_box();
test_rec();
test_tag();
pub fn hello() { inner2::hello(); }
}
-fn main() { inner::hello(); inner::inner2::hello(); }
+pub fn main() { inner::hello(); inner::inner2::hello(); }
struct X { x: uint, nxt: *foo }
-fn main() {
+pub fn main() {
let x = foo(X {x: 0, nxt: ptr::null()});
}
impl foo of plus for uint { fn plus() -> int { self as int + 20 } }
impl foo of plus for int { fn plus() -> int { self + 10 } }
-fn main() {
+pub fn main() {
assert 10.plus() == 20;
}
// -*- rust -*-
-fn main() { let x: int = 10; }
+pub fn main() { let x: int = 10; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
fn id_i8(n: i8) -> i8 { n }
fn id_i16(n: i16) -> i16 { n }
fn id_i32(n: i32) -> i32 { n }
// This is a testcase for issue #94.
-fn main() {
+pub fn main() {
let v: ~[int] = ~[0, 1, 2, 3, 4, 5];
let s: ~str = ~"abcdef";
assert (v[3u] == 3);
extern mod cci_intrinsic;
use cci_intrinsic::atomic_xchg;
-fn main() {
+pub fn main() {
unsafe {
let mut x = 1;
atomic_xchg(&mut x, 5);
pub fn atomic_xsub_rel(dst: &mut int, src: int) -> int;
}
-fn main() {
+pub fn main() {
unsafe {
let x = ~mut 1;
pub fn frame_address(f: &once fn(*u8));
}
-fn main() {
+pub fn main() {
unsafe {
do rusti::frame_address |addr| {
assert addr.is_not_null();
pub fn move_val<T>(dst: &mut T, -src: T);
}
-fn main() {
+pub fn main() {
unsafe {
let mut x = @1;
let mut y = @2;
fn bswap64(x: i64) -> i64;
}
-fn main() {
+pub fn main() {
unsafe {
use rusti::*;
fn truncf64(x: f64) -> f64;
}
-fn main() {
+pub fn main() {
unsafe {
use rusti::*;
extern mod foreign_lib;
-fn main() {
+pub fn main() {
let foo = foreign_lib::rustrt::last_os_error();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let ((),()) = ((),());
}
g: u8
}
-fn main() {
+pub fn main() {
let x: X<int> = X {
a: 12345678,
b: 9u8,
pub fn get_task_id() -> libc::intptr_t;
}
-fn main() { }
+pub fn main() { }
return plus_one;
}
-fn main() {
+pub fn main() {
let z = do (ret_plus_one()) || { 2 };
assert z == 3;
}
// except according to those terms.
-fn main() {
+pub fn main() {
{|i| if 1 == i { }};
}
// exec-env:RUST_CC_ZEAL=1
// xfail-test
-fn main() {
+pub fn main() {
error!("%?", os::getenv(~"RUST_CC_ZEAL"));
let _x = @{a: @10, b: ~true};
}
// except according to those terms.
// xfail-test
-fn main() { let early_error: fn@(str) -> ! = {|msg| die!() }; }
+pub fn main() { let early_error: fn@(str) -> ! = {|msg| die!() }; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
const _x: int = 1<<2;
}
use std::map;
use std::map::HashMap;
-fn main() {
+pub fn main() {
let m = map::HashMap();
m.insert(str::to_bytes(~"foo"), str::to_bytes(~"bar"));
log(error, m);
}
}
-fn main() {
+pub fn main() {
assert noise(cat(tabby)) == Some(~"meow");
assert noise(dog(pug)) == Some(~"woof");
assert noise(rabbit(~"Hilbert", upright)) == None;
enum t {
foo(~[t])
}
-fn main() {}
\ No newline at end of file
+pub fn main() {}
\ No newline at end of file
}
}
-fn main() { }
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = 1;
let y = fn@(move x) -> int {
x
// Issue 1974
// Don't double free the condition allocation
-fn main() {
+pub fn main() {
let s = ~"hej";
while s != ~"" {
return;
}
}
-fn main()
+pub fn main()
{
let v = ~[empty_pointy(), empty_pointy()];
v[0].a = p(v[0]);
new(*ar) s(str)
}
-fn main(args: ~[str]) {
+pub fn main(args: ~[str]) {
let ar = arena::Arena();
let leak = init(&ar, args[0]);
match *leak {
}
}
-fn main() {
+pub fn main() {
let range: fn@(fn&(uint)) = |a| range(0u, 1000u, a);
let filt: fn@(fn&(&&v: uint)) = |a| filter(
range,
}
}
-fn main() {
+pub fn main() {
task::spawn(child_no(0));
}
mod a {
fn foo(f: fn&()) { f() }
fn bar() {}
-fn main() { foo(||bar()); }
+pub fn main() { foo(||bar()); }
}
mod b {
fn foo(f: Option<fn&()>) { f.iter(|x|x()) }
fn bar() {}
-fn main() { foo(Some(bar)); }
+pub fn main() { foo(Some(bar)); }
}
mod c {
fn foo(f: Option<fn&()>) { f.iter(|x|x()) }
fn bar() {}
-fn main() { foo(Some(||bar())); }
+pub fn main() { foo(Some(||bar())); }
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
f: fn~()
};
-fn main() {
+pub fn main() {
let _t: t = { f: {||()} };
}
use c(name = "issue2196c");
use c::t;
-fn main() { }
+pub fn main() { }
}
-fn main() {
+pub fn main() {
let mut y: int = 5;
let x: &mut int = &mut y;
assert (lgamma(1.0 as c_double, x) == 0.0 as c_double);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut x = 0;
loop foo: {
t.f();
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
x.chowder(a);
}
-fn main() {
+pub fn main() {
let c = foo(42);
let d: clam<int> = c as clam::<int>;
}
}
-fn main() { }
+pub fn main() { }
fn bar<B,C:clam<A>>(c: C) -> B;
}
-fn main() { }
+pub fn main() { }
fn bar<B,C:clam<B>>(c: C) -> B { die!(); }
}
-fn main() { }
+pub fn main() { }
extern mod issue_2316_b;
use issue_2316_b::cloth;
-fn main() {
+pub fn main() {
let _c: cloth::fabric = cloth::calico;
}
\ No newline at end of file
extern mod a;
-fn main() {
+pub fn main() {
a::f::<()>();
}
use std::deque;
use std::deque::Deque;
-fn main() {
+pub fn main() {
let Q = deque::create();
Q.add_back(10);
}
extern mod b;
-fn main() {}
+pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let foo = 100;
const quux: int = 5;
}
-fn main() {
+pub fn main() {
c1::<int>(3).f1(4);
c1::<int>(3).f2(4);
}
}
-fn main() {
+pub fn main() {
c1::<int>(3).f1(4);
c1::<int>(3).f2(4);
}
struct Pair { f: int, g: int }
-fn main() {
+pub fn main() {
let x = Pair {
f: 0,
use issue_2472_b::{S, T};
-fn main() {
+pub fn main() {
let s = S(());
s.foo();
s.bar();
fn setsockopt_bytes(_sock: int) { }
-fn main() {}
+pub fn main() {}
}
}
-fn main() { }
+pub fn main() { }
extern mod issue_2526;
use issue_2526::*;
-fn main() {}
+pub fn main() {}
}
#[deny(non_implicitly_copyable_typarams)]
-fn main() {
+pub fn main() {
f(C(1u));
}
}
}
-fn main() {}
+pub fn main() {}
use std::map::*;
use std::map::HashMap;
-fn main() {
+pub fn main() {
let v = ~[@~"hi"];
let m: req::header_map = HashMap();
m.insert(~"METHOD", @dvec::from_vec(v));
*x + *y
}
-fn main() {
+pub fn main() {
let z = ~22;
a_val(copy z, copy z);
}
(kitty.meow)();
}
-fn main() {
+pub fn main() {
let mut kitty = cat();
nyan(copy kitty, KittyInfo {kitty: copy kitty});
}
let _x: uint = loop { loop { break; } };
}
-fn main() {
+pub fn main() {
}
}
}
-fn main() {
+pub fn main() {
let _f = @Font();
}
log(error, ~"Sent pong");
}
-fn main() {
+pub fn main() {
/*
// Commented out because of option::get error
extern mod issue_2723_a;
use issue_2723_a::*;
-fn main() {
+pub fn main() {
unsafe {
f(~[2]);
}
perform_hax(@~"deadcode");
}
-fn main() {
+pub fn main() {
let _ = perform_hax(@42);
}
}
}
-fn main() {
+pub fn main() {
let mut dtor_ran = false;
let _ = defer(&mut dtor_ran);
assert(dtor_ran);
}
}
-fn main() {
+pub fn main() {
let mut dtor_ran = false;
defer(&mut dtor_ran);
assert(dtor_ran);
perform_hax(@~"deadcode");
}
-fn main() {
+pub fn main() {
perform_hax(@42);
}
}
}
-fn main() { }
+pub fn main() { }
// except according to those terms.
fn thing(x: &r/[int]) -> &r/[int] { x }
-fn main() {
+pub fn main() {
let x = &[1,2,3];
let y = x;
let z = thing(x);
error!("%s, %?", managed_ip, device[~"interfaces"]);
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {}
+pub fn main() {}
error!("%?", streams[0]);
}
-fn main() {
+pub fn main() {
//os::getenv("FOO");
rendezvous();
}
}
}
-fn main() {}
+pub fn main() {}
}
#[cfg(target_arch = "x86_64")]
-fn main() {
+pub fn main() {
assert (sys::size_of::<Cat>() == 8 as uint);
assert (sys::size_of::<Kitty>() == 16 as uint);
}
#[cfg(target_arch = "x86")]
-fn main() {
+pub fn main() {
assert (sys::size_of::<Cat>() == 4 as uint);
assert (sys::size_of::<Kitty>() == 8 as uint);
}
}
}
-fn main() {}
+pub fn main() {}
}
)
-fn main() {
+pub fn main() {
let (bc, _bp) = stream::init();
stream::client::send(move bc, ~"abc");
fn f() { }
}
-fn main() {
+pub fn main() {
// let x = ({a: 4i} as it);
// let y = @({a: 4i});
// let z = @({a: 4i} as it);
}
}
-fn main() {
+pub fn main() {
let x: int = foo::<int, cbar>(cbar(5));
assert x == 5;
}
struct Storage { storage: ~[u64] }
-fn main() {
+pub fn main() {
let bools = ~[false, false, true, false, false, true, true, false];
let bools2 = to_bools(Storage{storage: ~[0b01100100]});
extern mod socketlib;
use socketlib::socket;
-fn main() {
+pub fn main() {
let fd: libc::c_int = 1 as libc::c_int;
let sock = @socket::socket_handle(fd);
}
use std::map::HashMap;
use std::map;
-fn main() {
+pub fn main() {
let buggy_map :HashMap<uint, &uint> = HashMap::<uint, &uint>();
let x = ~1;
buggy_map.insert(42, &*x);
}
}
-fn main()
+pub fn main()
{
}
Some(mock_connection)
}
-fn main() {
+pub fn main() {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = 1;
let y = 1;
assert &x == &y;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
log(error, ("hi there!", "you"));
}
}
}
-fn main() {
+pub fn main() {
foo(@for_here(hamburger), true)
}
m41: T, m42: T, m43: T, m44: T,
}
-fn main() {}
+pub fn main() {}
// xfail-fast
-fn main() {
+pub fn main() {
let (p,c) = pipes::stream();
do task::try |move c| {
let (p2,c2) = pipes::stream();
use pipes::{Select2, Selectable};
-fn main() {
+pub fn main() {
let (p,c) = pipes::stream();
do task::try |move c| {
let (p2,c2) = pipes::stream();
enum x {}
-fn main() {}
+pub fn main() {}
-fn main() {
+pub fn main() {
let mut x = 0;
for 4096.times {
x += 1;
}
impl thing { fn f(self) {} }
-fn main() {
+pub fn main() {
let z = thing();
(move z).f();
}
-fn main() { }
+pub fn main() { }
assert x.double() == exp;
}
-fn main() {
+pub fn main() {
let x = @(3u as double);
is_equal(x, 6);
}
fn id<T: Copy>(x: T) -> T { return x; }
-fn main() { assert (quux(10) == 10); }
+pub fn main() { assert (quux(10) == 10); }
}
}
-fn main() {
+pub fn main() {
let node: trie_node = trie_node {
content: ~[],
children: ~[]
assert loader(&path).is_ok();
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {
+pub fn main() {
let s = @"str";
let ls = list {
element: &s,
// except according to those terms.
// xfail-test
-fn main() {
+pub fn main() {
fn foo() { }
}
}
-fn main() {}
\ No newline at end of file
+pub fn main() {}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = &Some(1);
match x {
&Some(_) => (),
assert check_strs(table.to_str(), ~"xxx"); // not sure what expected should be
}
-fn main() {}
+pub fn main() {}
}
-fn main() {}
+pub fn main() {}
assert check_strs(art.to_str(), "****\n*..*\n*.**\n****");
}
-fn main() {
+pub fn main() {
test_ascii_art_ctor();
test_add_pt();
test_shapes();
}
}
-fn main()
+pub fn main()
{
assert compare("foo", "foo");
assert compare(@"foo", @"foo");
};
}
-fn main() {}
+pub fn main() {}
pub fn malloc(++data: KEYGEN);
}
-fn main() {
+pub fn main() {
}
}
}
-fn main() {
+pub fn main() {
assert(3.b() == 5);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
trait Text {
fn to_str(&self) -> ~str;
}
}
}
-fn main(){
+pub fn main(){
let s = Circle(Point { x: 1f, y: 2f }, 3f);
io::println(fmt!("%f", s.area(s)));
}
\ No newline at end of file
s.print();
}
-fn main() {
+pub fn main() {
let s: @S = @S { s: 5 };
print_s(s);
let t: @T = s as @T;
pub struct Tower { height: uint }
}
-fn main() {
+pub fn main() {
let sears = buildings::Tower { height: 1451 };
let h: uint = match sears {
buildings::Tower { height: h } => { h }
}
}
-fn main() {
+pub fn main() {
let mut x = @mut Foo { x: 3 };
// Neither of the next two lines should cause an error
let _ = x.stuff();
blk(x);
}
-fn main() {}
+pub fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main()
+pub fn main()
{
let y = ~1;
move y;
vec::view(v, 1, 5)
}
-fn main() {}
+pub fn main() {}
// except according to those terms.
// xfail-test
-fn main() {
+pub fn main() {
enum State { BadChar, BadSyntax }
match BadChar {
}
}
-fn main(){
+pub fn main(){
let val = &X{
err: example_err,
};
}
}
-fn main() {}
+pub fn main() {}
impl Point: Movable<int, int>;
-fn main() {
+pub fn main() {
let p = Point{ x: 1, y: 2};
p.translate(3);
assert p.X() == 4;
impl Point: Movable;
-fn main() {
+pub fn main() {
let p = Point{ x: 1, y: 2};
p.translate(3);
assert p.X() == 4;
impl Point: Movable;
-fn main() {
+pub fn main() {
let p = Point{ x: 1, y: 2};
p.translate(3);
assert p.X() == 4;
die!()
}
-fn main() {}
+pub fn main() {}
extern mod std;
-fn main() {
+pub fn main() {
let x = std::map::HashMap();
x.insert((@"abc", 0), 0);
}
-fn main() {
+pub fn main() {
let mut count = 0;
for 999_999.times() {
count += 1;
return ~""
}
-fn main() {
+pub fn main() {
io::println(parse_args());
}
// except according to those terms.
// xfail-test
-fn main() {
+pub fn main() {
for os::args().each |arg| {
match copy *arg {
s => { }
fn f<T>(g: fn() -> T) -> T { g() }
-fn main() {
+pub fn main() {
let _x = f( | | { 10 });
// used to be: cannot determine a type for this expression
f(| | { });
// xfail-test
fn find<T>(_f: fn(@T) -> bool, _v: [@T]) {}
-fn main() {
+pub fn main() {
let x = 10, arr = [];
find({|f| f.id == x}, arr);
arr += [{id: 20}]; // This assigns a type to arr
}
}
-fn main() {
+pub fn main() {
let b = @mut 0;
{
let p = Some(r(b));
mut x : maybe_pointy
}
-fn main() {
+pub fn main() {
let m = @Pointy { mut x : no_pointy };
m.x = yes_pointy(m);
}
// aux-build:issue2170lib.rs
extern mod issue2170lib;
-fn main() {
+pub fn main() {
// let _ = issue2170lib::rsrc(2i32);
}
use issue2378a::{just, methods};
use issue2378b::{methods};
-fn main() {
+pub fn main() {
let x = {a: just(3), b: just(5)};
assert x[0u] == (3, 5);
}
extern mod issue4516_ty_param_lib;
use issue4516_ty_param_lib::to_closure;
-fn main() {
+pub fn main() {
to_closure(22)();
}
// aux-build:issue_3136_a.rc
extern mod issue_3136_a;
-fn main() {}
+pub fn main() {}
extern mod linenoise;
use linenoise::issue_3882::*;
-fn main() {}
+pub fn main() {}
assert (s == ~"coffee&tea");
}
-fn main() {
+pub fn main() {
test_stack_assign();
test_heap_lit();
test_heap_assign();
#[inner_fn_attr];
}
-fn main() { }
+pub fn main() { }
//
// Local Variables:
pub fn baz() { }
}
-fn main() { }
+pub fn main() { }
fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
-fn main() {
+pub fn main() {
assert ![1u, 2u].all(is_even);
assert [2u, 4u].all(is_even);
assert [].all(is_even);
fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
-fn main() {
+pub fn main() {
assert ![1u, 3u].any(is_even);
assert [1u, 2u].any(is_even);
assert ![].any(is_even);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
assert [].contains(&22u) == false;
assert [1u, 3u].contains(&22u) == false;
assert [22u, 1u, 3u].contains(&22u) == true;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
assert [].count(&22u) == 0u;
assert [1u, 3u].count(&22u) == 0u;
assert [22u, 1u, 3u].count(&22u) == 1u;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut c = 0u;
for [1u, 2u, 3u, 4u, 5u].eachi |i, v| {
assert (i + 1u) == *v;
fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
-fn main() {
+pub fn main() {
assert [1, 3].filter_to_vec(is_even) == ~[];
assert [1, 2, 3].filter_to_vec(is_even) == ~[2];
assert None.filter_to_vec(is_even) == ~[];
if (*x % 2u) == 0u {Some(*x + 1u)} else {None}
}
-fn main() {
+pub fn main() {
assert (~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u];
assert (~[]).flat_map_to_vec(repeat) == ~[];
assert None.flat_map_to_vec(repeat) == ~[];
fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) }
-fn main() {
+pub fn main() {
assert [1u, 3u].foldl(20f, add) == 24f;
assert [].foldl(20f, add) == 20f;
assert None.foldl(20f, add) == 20f;
fn inc(x: &uint) -> uint { *x + 1 }
-fn main() {
+pub fn main() {
assert [1, 3].map_to_vec(inc) == ~[2, 4];
assert [1, 2, 3].map_to_vec(inc) == ~[2, 3, 4];
assert None.map_to_vec(inc) == ~[];
fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
-fn main() {
+pub fn main() {
assert [1u, 3u].min() == 1u;
assert [3u, 1u].min() == 1u;
assert Some(1u).min() == 1u;
while i < b { it(i); i += 1; }
}
-fn main() {
+pub fn main() {
let mut sum: int = 0;
range(0, 100, |x| sum += x );
log(debug, sum);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
assert [1u, 3u].to_vec() == ~[1u, 3u];
let e: ~[uint] = ~[];
assert e.to_vec() == ~[];
fn double_int(a: int) -> ~[int] { return ~[a] + ~[a]; }
-fn main() {
+pub fn main() {
let mut d = double(1);
assert (d[0] == 1);
assert (d[1] == 1);
// except according to those terms.
fn f(a: ~[int]) { }
-fn main() { f(~[1, 2, 3, 4, 5]); }
+pub fn main() { f(~[1, 2, 3, 4, 5]); }
13u8]);
}
-fn main() {
+pub fn main() {
let (p, ch) = stream::<~[u8]>();
let prod = task::spawn(|| producer(&ch) );
// mod -> module
// match -> match
-fn main() {
+pub fn main() {
}
mod foo {
v as repeat::<A> // No
}
-fn main() {
+pub fn main() {
let x = &3;
let y = repeater(@x);
assert *x == *(y.get());
// xfail-fast
// xfail-test
-fn main() {
+pub fn main() {
loop foo: {
loop {
break foo;
struct Refs { mut refs: ~[int], n: int }
-fn main() {
+pub fn main() {
let e = @Refs{mut refs: ~[], n: 0};
let f = fn@ () { log(error, e.n); };
e.refs += ~[1];
// Make sure we don't leak fn@s in silly ways.
fn force(f: fn@()) { f() }
-fn main() {
+pub fn main() {
let x = 7;
let _f = fn@() { log(error, x); };
force(fn@() { log(error, x); });
l: 0};
}
-fn main() { f(); }
+pub fn main() { f(); }
g(s, |v| { let r = f(v); move r })
}
-fn main() {}
+pub fn main() {}
return fn@(move k) -> int { 22 };
}
-fn main() {
+pub fn main() {
assert foo()() == 22;
}
struct A { a: ~int }
-fn main() {
+pub fn main() {
fn invoke(f: fn@()) { f(); }
let k = ~22;
let _u = A {a: copy k};
fn incr(x: &mut int) -> bool { *x += 1; assert (false); return false; }
-fn main() {
+pub fn main() {
let x = 1 == 2 || 3 == 3;
assert (x);
let mut y: int = 10;
fn foo(x: int) { log(debug, x); }
-fn main() { let mut x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }
+pub fn main() { let mut x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }
fn leaky<T>(t: T) { }
-fn main() { let x = @10; leaky::<@int>(x); }
+pub fn main() { let x = @10; leaky::<@int>(x); }
enum t { a, b(@int), }
-fn main() { let mut x = b(@10); x = a; }
+pub fn main() { let mut x = b(@10); x = a; }
fn leaky<T>(t: T) { }
-fn main() { let x = ~10; leaky::<~int>(x); }
+pub fn main() { let x = ~10; leaky::<~int>(x); }
io::println(b);
}
-fn main() {
+pub fn main() {
f();
}
struct X { x: int, y: @A }
struct A { a: int }
-fn main() {
+pub fn main() {
let u = X {x: 10, y: @A {a: 20}};
let mut X {x: x, y: @A {a: a}} = u;
x = 100;
struct X { x: xx, y: int }
-fn main() {
+pub fn main() {
let @X {x: xx(x), y: y} = @X{x: xx(10), y: 20};
assert (x + y == 30);
}
-fn main() {
+pub fn main() {
let x = ~[1, 2, 3];
let mut y = 0;
for x.each |i| { log(debug, *i); y += *i; }
#[forbid(non_camel_case_types)]
type Foo_ = int;
-fn main() { }
+pub fn main() { }
// except according to those terms.
#[warn(structural_records)];
-fn main() {
+pub fn main() {
let _foo = {x:5};
}
\ No newline at end of file
// -*- rust -*-
enum list { cons(int, @list), nil, }
-fn main() { cons(10, @cons(11, @cons(12, @nil))); }
+pub fn main() { cons(10, @cons(11, @cons(12, @nil))); }
v = 2;
}
-fn main() {
+pub fn main() {
// note: don't call test()... :)
}
_v = 2; //~ WARNING: unreachable statement
}
-fn main() {
+pub fn main() {
}
debug!("%d", v);
}
-fn main() {
+pub fn main() {
test();
}
}
}
-fn main() {}
+pub fn main() {}
enum Foo = uint;
-fn main() {
+pub fn main() {
let x = Foo(1);
let y = fmt!("%?", x);
assert y == ~"Foo(1)";
-fn main() { if false { log(error, ~"foo" + ~"bar"); } }
+pub fn main() { if false { log(error, ~"foo" + ~"bar"); } }
assert exp == fmt!("%?", v);
}
-fn main() {
+pub fn main() {
let x = list::from_vec(~[a(22u), b(~"hi")]);
let exp = ~"@Cons(a(22), @Cons(b(~\"hi\"), @Nil))";
let act = fmt!("%?", x);
d, e, f
}
-fn main() {
+pub fn main() {
assert ~"a(22)" == fmt!("%?", a(22u));
assert ~"b(~\"hi\")" == fmt!("%?", b(~"hi"));
assert ~"c" == fmt!("%?", c);
log(error, sim);
}
-fn main() {
+pub fn main() {
f::<int,int>();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let act = sys::log_str(&~[1, 2, 3]);
assert ~"~[1, 2, 3]" == act;
-fn main() { let mut i: int = 0; while i < 1000000 { i += 1; let x = 3; } }
+pub fn main() { let mut i: int = 0; while i < 1000000 { i += 1; let x = 3; } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = 0u;
loop {
break;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut i = 0u;
loop {
log(error, ~"a");
loop{}
}
-fn main() {
+pub fn main() {
if (1 == 2) { forever(); }
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = ~[10, 20, 30];
let mut sum = 0;
for x.each |x| { sum += *x; }
task::spawn(|| die() );
}
-fn main() {
+pub fn main() {
for uint::range(0u, 100u) |_i| {
task::spawn_unlinked(|| iloop() );
}
// xfail-pretty - token trees can't pretty print
-fn main() {
+pub fn main() {
macro_rules! mylambda_tt(
($x:ident, $body:expr) => ({
})
)
-fn main() {
+pub fn main() {
assert overly_complicated!(f, x, Option<uint>, { return Some(x); },
Some(8u), Some(y), y) == 8u
})
}
-fn main() {
+pub fn main() {
assert foo!(m::t) == 10;
}
myfn!(add, (a,b), { return a+b; } )
-fn main() {
+pub fn main() {
macro_rules! mylet(
($x:ident, $val:expr) => (
Foo { x: x, y: y }
}
-fn main() {
+pub fn main() {
let foo = Foo(3, 20);
io::println(fmt!("%d %d", foo.sum(), foo.product()));
}
return i;
}
-fn main() {
+pub fn main() {
let v0 = ~[1, 2, 3, 4, 5];
log(debug, len(v0));
let v1 = ~[mut 1, 2, 3, 4, 5];
}
}
-fn main() { }
+pub fn main() { }
enum list { link(@cell), nil, }
-fn main() {
+pub fn main() {
let first: @cell = @{mut c: @nil()};
let second: @cell = @{mut c: @link(first)};
first._0 = @link(second);
enum mlist { cons(int, @mlist), nil, }
-fn main() { cons(10, @cons(11, @cons(12, @nil))); }
+pub fn main() { cons(10, @cons(11, @cons(12, @nil))); }
m::g()
}
-fn main() {
+pub fn main() {
assert f() == 720;
}
#[merge = "mod-merge-hack-inst.rs"]
mod myint32;
-fn main() {
+pub fn main() {
assert myint32::bits == 32;
assert myint32::min(10, 20) == 10;
}
\ No newline at end of file
pub fn f() -> ~[int] { vec::from_elem(1u, 0) }
}
-fn main() { let x = m::f(); }
+pub fn main() { let x = m::f(); }
pub mod syrup;
}
-fn main() {
+pub fn main() {
assert mod_dir_simple::syrup::foo() == 10;
}
pub mod syrup;
}
-fn main() {
+pub fn main() {
assert pancakes::syrup::foo() == 10;
}
pub mod test;
}
-fn main() {
+pub fn main() {
assert pancakes::test::foo() == 10;
}
pub mod test;
}
-fn main() {
+pub fn main() {
assert biscuits::test::foo() == 10;
assert gravy::test::foo() == 10;
}
pub mod load_another_mod;
}
-fn main() {
+pub fn main() {
assert mod_dir_simple::load_another_mod::test::foo() == 10;
}
pub mod test;
}
-fn main() {
+pub fn main() {
assert mod_dir_simple::test::foo() == 10;
}
mod mod_file_aux;
-fn main() {
+pub fn main() {
assert mod_file_aux::foo() == 10;
}
\ No newline at end of file
#[path = "mod_file_aux.rs"]
mod m;
-fn main() {
+pub fn main() {
assert m::foo() == 10;
}
\ No newline at end of file
}
}
-fn main() {
+pub fn main() {
let x = m::S { x: 1, y: 2 };
let m::S { x: a, y: b } = x;
}
x.bind(|n| Some(n + 1) ).bind(|n| Some(int::str(n)) )
}
-fn main() {
+pub fn main() {
assert transform(Some(10)) == Some(~"11");
assert transform(None) == None;
assert (~[~"hi"])
fn mk() -> uint { 22u }
}
-fn main() {
+pub fn main() {
let fn_env = fn@() -> uint {
mk_nil(())
};
impl io::Writer: Serializer {
}
-fn main() {
+pub fn main() {
do io::with_str_writer |wr| {
let foo = F { a: 1 };
foo.serialize(wr);
pub fn morestack_addr() -> *();
}
-fn main() {
+pub fn main() {
unsafe {
let addr = rusti::morestack_addr();
assert addr.is_not_null();
}
}
-fn main() {
+pub fn main() {
getbig(100000);
}
\ No newline at end of file
m
}
-fn main() {
+pub fn main() {
getbig(10000);
}
\ No newline at end of file
return a0;
}
-fn main() {
+pub fn main() {
let a = 10000;
getbig(a, a+1, a+2, a+3, a+4, a+5, a+6, a+7, a+8, a+9);
}
\ No newline at end of file
}
}
-fn main() {
+pub fn main() {
getbig(Biggy {
a00: 10000u64,
a01: 10000u64,
}
}
-fn main() {
+pub fn main() {
let mut sz = 400u;
while sz < 500u {
task::try(|| getbig(200) );
}
}
-fn main() {
+pub fn main() {
let fns = ~[
calllink01,
calllink02,
return y.y;
}
-fn main() {
+pub fn main() {
let x = ~Triple{x: 1, y: 2, z: 3};
assert (test(true, copy x) == 2);
assert (test(true, copy x) == 2);
return y.y;
}
-fn main() {
+pub fn main() {
let x = @Triple {x: 1, y: 2, z: 3};
assert (test(true, x) == 2);
assert (test(true, x) == 2);
struct X { x: int, y: int, z: int }
-fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
+pub fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
struct X { x: int, y: int, z: int }
-fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
+pub fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = move x; assert (y.y == 2); }
return y.y;
}
-fn main() {
+pub fn main() {
let x = ~Triple{x: 1, y: 2, z: 3};
for uint::range(0u, 10000u) |_i| {
assert (test(true, copy x) == 2);
return y.y;
}
-fn main() {
+pub fn main() {
let x = @Triple{x: 1, y: 2, z: 3};
for uint::range(0u, 10000u) |i| {
assert (test(true, x) == 2);
return quux;
}
-fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); assert (y.c == 3); }
+pub fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); assert (y.c == 3); }
return quux;
}
-fn main() {
+pub fn main() {
let x = @Triple{a: 1, b: 2, c: 3};
let y = test(x);
assert (y.c == 3);
fn test(-foo: ~~[int]) { assert (foo[0] == 10); }
-fn main() {
+pub fn main() {
let x = ~~[10];
// Test forgetting a local by move-in
test(move x);
fn test(-foo: @~[int]) { assert (foo[0] == 10); }
-fn main() {
+pub fn main() {
let x = @~[10];
// Test forgetting a local by move-in
test(move x);
fn test(-foo: int) { assert (foo == 10); }
-fn main() { let x = 10; test(move x); }
+pub fn main() { let x = 10; test(move x); }
f2(move thing);
}
-fn main() {
+pub fn main() {
f(fn@() {});
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let y: int = 42;
let mut x: int;
}
}
-fn main() {
+pub fn main() {
let x = S { x: ~"Hello!" };
x.foo();
}
-fn main() {
+pub fn main() {
let x = ~"Hello world!";
do task::spawn {
io::println(x);
extern mod moves_based_on_type_lib;
use moves_based_on_type_lib::f;
-fn main() {
+pub fn main() {
f();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let x = 10, y = x; assert (y == 10); }
+pub fn main() { let x = 10, y = x; assert (y == 10); }
/*
* This is a multi-line oldcomment.
*/
-fn main() { }
+pub fn main() { }
fn f<T:Eq + Ord>(_: T) {
}
-fn main() {
+pub fn main() {
f(3);
}
}
-fn main() {
+pub fn main() {
let z = ~17;
f(z);
g();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x: &mut [int] = &mut [ 1, 2, 3 ];
}
for ints.each |i| { assert *i == 22; }
}
-fn main() {
+pub fn main() {
test1();
test2();
}
fn grow(v: &mut ~[int]) { *v += ~[1]; }
-fn main() {
+pub fn main() {
let mut v: ~[int] = ~[];
grow(&mut v);
grow(&mut v);
// error-pattern: mismatched types
-fn main() {
+pub fn main() {
let v = ~[~[0]];
// This is ok because the outer vec is covariant with respect
// error-pattern: mismatched types
-fn main() {
+pub fn main() {
let v = ~[~[0]];
// This is ok because the outer vec is covariant with respect
struct Pair { a: int, b: int}
-fn main() {
+pub fn main() {
// This just tests whether the vec leaks its members.
let pvec: ~[mut @Pair] =
~[mut @Pair{a: 1, b: 2}, @Pair{a: 3, b: 4}, @Pair{a: 5, b: 6}];
enum small_list { kons(int, @small_list), neel, }
-fn main() { }
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
match -5 {
-5 => {}
_ => { die!() }
}
}
-fn main() { foo(); }
+pub fn main() { foo(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
struct b {
i: int,
struct Foo { foo: bool, bar: Option<int>, baz: int }
-fn main() {
+pub fn main() {
match @Foo{foo: true, bar: Some(10), baz: 20} {
@Foo{foo: true, bar: Some(_), _} => {}
@Foo{foo: false, bar: None, _} => {}
}
}
-fn main() { nested(bar(1, None::<int>)); }
+pub fn main() { nested(bar(1, None::<int>)); }
struct D { a: int, d: C }
struct C { mut c: int }
-fn main() {
+pub fn main() {
match A {a: 10, b: @20} {
x@A {a, b: @20} => { assert x.a == 10; assert a == 10; }
A {b, _} => { die!(); }
}
}
-fn main() {
+pub fn main() {
io::println(Thingy { x: 1, y: 2 }.to_str());
io::println(PolymorphicThingy { x: Thingy { x: 1, y: 2 } }.to_str());
}
use io::println;
-fn main() {
+pub fn main() {
println("Hello world!");
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x: @mut [int] = @mut [ 1, 2, 3 ];
}
fn unique() -> fn~() { return || (); }
-fn main() {
+pub fn main() {
}
fn unique() -> fn~() { || () }
-fn main() {
+pub fn main() {
}
return |x| x + 1;
}
-fn main() {
+pub fn main() {
assert f(10, |a| a) == 10;
g(||());
assert do f(10) |a| { a } == 10;
fn myvec_elt<X: Copy>(mv: myvec<X>) -> X { return mv[0]; }
-fn main() {
+pub fn main() {
let mv = myvec(~[1, 2, 3]);
assert (myvec_deref(copy mv)[1] == 2);
assert (myvec_elt(copy mv) == 1);
fn compute(i: mytype) -> int { return i.val + 20; }
-fn main() {
+pub fn main() {
let myval = mytype(Mytype{compute: compute, val: 30});
assert ((myval.compute)(myval) == 50);
}
extern mod libc {
pub fn printf(x: ());
}
-fn main() { }
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let x = (); match x { () => { } } }
+pub fn main() { let x = (); match x { () => { } } }
return head(ls);
}
-fn main() {
+pub fn main() {
let mylist = @Cons(@1u, @Nil);
assert (nonempty_list(mylist));
assert (*safe_head(mylist) == 1u);
check_int(x.repr);
}
-fn main() {
+pub fn main() {
apply(22, check_int);
apply(X {repr: 22}, check_struct);
}
match q { a | b => { 42 } }
}
-fn main() {
+pub fn main() {
assert (or_alt(a) == 42);
assert (or_alt(b) == 42);
}
// reachable for each numeric type, for each exported impl, with no imports
// necessary. Testing the methods of the impls is done within the source
// file for each numeric type.
-fn main() {
+pub fn main() {
// ints
// num
assert 15i.add(&6) == 21;
// -*- rust -*-
-fn main() {
+pub fn main() {
let mut x: int = 1;
x *= 2;
log(debug, x);
// Testcase for issue #130, operator associativity.
-fn main() { assert (3 * 5 / 2 == 7); }
+pub fn main() { assert (3 * 5 / 2 == 7); }
}
}
-fn main() {
+pub fn main() {
let mut s = S { x: 1 };
s += S { x: 2 };
assert s.x == 3;
pure fn ne(&self, other: &Point) -> bool { !(*self).eq(other) }
}
-fn main() {
+pub fn main() {
let mut p = Point {x: 10, y: 20};
p += Point {x: 101, y: 102};
p = p - Point {x: 100, y: 100};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let thing = ~"{{ f }}";
let f = str::find_str(thing, ~"{{");
}
}
-fn main() {
+pub fn main() {
let x = @mut 1;
{
match q { a(x, y, _) | b(x, y) => { return x + y; } c => { return 0; } }
}
-fn main() {
+pub fn main() {
assert (or_alt(c) == 0);
assert (or_alt(a(10, 100, 0u)) == 110);
assert (or_alt(b(20, 200)) == 220);
fn ret_ext_ext_mem() -> @Abox { return @Abox{a: @10, b: @10}; }
-fn main() {
+pub fn main() {
let mut int_i: int;
let mut ext_i: @int;
let mut int_rec: A;
// Regression test for issue #152.
-fn main() {
+pub fn main() {
let mut b: uint = 1u;
while b <= 32u {
0u << b;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = true;
if x { let mut i = 10; while i > 0 { i -= 1; } }
match x { true => { debug!("right"); } false => { debug!("wrong"); } }
// -*- rust -*-
fn dont_call_me() { die!(); log(debug, 1); }
-fn main() { }
+pub fn main() { }
struct A { a: @int }
-fn main() {
+pub fn main() {
let a = A {a: @10}, b = @10;
magic(a); magic(A {a: @20});
magic2(b); magic2(@20);
pub fn bar(offset: uint) { }
}
-fn main() { foo::bar(0u); }
+pub fn main() { foo::bar(0u); }
}
}
-fn main() { foo(0u); }
+pub fn main() { foo(0u); }
y: int
}
-fn main() {
+pub fn main() {
let f = |(x, _): (int, int)| io::println((x + 1).to_str());
let g = |Foo { x: x, y: y }: Foo| io::println((x + 1).to_str());
f((2, 3));
}
}
-fn main() {
+pub fn main() {
}
}
)
-fn main() {
+pub fn main() {
let iotask = &uv::global_loop::get();
pipes::spawn_service(oneshot::init, |p| {
}
)
-fn main() {
+pub fn main() {
let (c, p) = oneshot::init();
assert !pipes::peek(&p);
}
}
-fn main() {
+pub fn main() {
let (client_, server_) = ::pingpong::init();
let client_ = ~mut Some(move client_);
let server_ = ~mut Some(move server_);
}
}
-fn main() {
+pub fn main() {
let (client_, server_) = pingpong::init();
let client_ = ~mut Some(move client_);
let server_ = ~mut Some(move server_);
);
}
-fn main() { }
+pub fn main() { }
)
}
-fn main() {
+pub fn main() {
}
}
)
-fn main() {
+pub fn main() {
use oneshot::client::*;
use stream::client::*;
}
)
-fn main() {
+pub fn main() {
use oneshot::client::*;
let c = pipes::spawn_service(oneshot::init, |p| { recv(move p); });
extern mod std;
use std::arena;
-fn main() {
+pub fn main() {
let p = &arena::Arena();
let x = p.alloc(|| 4u);
io::print(fmt!("%u", *x));
// The OS main scheduler should continue to be available and not terminate
// while it is not in use.
-fn main() {
+pub fn main() {
run(100);
}
pure fn bad(a: int) -> int { return 37; } //~ ERROR Non-boolean return type
-fn main() { }
+pub fn main() { }
loop { i += 1; }
}
-fn main() {
+pub fn main() {
let alive: port<int> = port();
debug!("main started");
let s: task = spawn starve_main(chan(alive));
}
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
assert (nyan.meow_count() == 52u);
}
}
}
-fn main() {
+pub fn main() {
let nyan : cat = cat(52u, 99);
nyan.play();
}
// did not, then the type of `x` would not be known and a compilation
// error would result.
-fn main() {
+pub fn main() {
let y = ~3;
let foo: @fn(&int) -> int = {
let y = copy y;
use pub_use_xcrate2::Foo;
-fn main() {
+pub fn main() {
let foo: Foo = Foo {
name: 0
};
extern mod pub_use_mods_xcrate;
use pub_use_mods_xcrate::a::c;
-fn main(){}
+pub fn main(){}
debug!("test %b", a.g);
}
-fn main() {
+pub fn main() {
}
return *sum0.f == sum;
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
fn something(f: pure fn()) { f(); }
-fn main() {
+pub fn main() {
something(|| log(error, "hi!") );
}
}
}
-fn main() {
+pub fn main() {
/*
let x = @mut 6;
let y = x.get();
fn call_sum(x: &[int]) -> int { x.sum() }
-fn main() {
+pub fn main() {
let x = ~[1, 2, 3];
let y = call_sum(x);
debug!("y==%d", y);
fn f(p: Point) { assert (p.z == 12); }
-fn main() { let x: Point = Point {x: 10, y: 11, z: 12}; f(x); }
+pub fn main() { let x: Point = Point {x: 10, y: 11, z: 12}; f(x); }
pub fn size() -> uint { 8u }
}
-fn main() {
+pub fn main() {
unsafe {
let x = Outer {c8: 22u8, t: Inner {c64: 44u32}};
}
}
-fn main() {
+pub fn main() {
unsafe {
let x = Outer {c8: 22u8, t: Inner {c64: 44u64}};
struct X { foo: ~str, bar: ~str }
-fn main() {
+pub fn main() {
let x = X {foo: ~"hello", bar: ~"world"};
log(debug, copy x.foo);
log(debug, copy x.bar);
// -*- rust -*-
struct Point {x: int, y: int}
-fn main() {
+pub fn main() {
let origin: Point = Point {x: 0, y: 0};
let right: Point = Point {x: origin.x + 10,.. origin};
let up: Point = Point {y: origin.y + 10,.. origin};
assert (snd(r).y == y2);
}
-fn main() {
+pub fn main() {
let r: rect = (Point {x: 10, y: 20}, Point {x: 11, y: 22});
assert (fst(r).x == 10);
assert (fst(r).y == 20);
assert (r.h == h);
}
-fn main() {
+pub fn main() {
let r: Rect = Rect {x: 10, y: 20, w: 100, h: 200};
assert (r.x == 10);
assert (r.y == 20);
}
}
-fn main() {
+pub fn main() {
assert (m(c(T2 {x: a(10), y: 5}, 4u)) == 10);
assert (m(c(T2 {x: b(10u), y: 5}, 4u)) == 19);
}
_ => {test (n-1, i+1, Cons {head:2*i+1, tail:first}, Cons{head:i*i, tail:second})}
}
}
-fn main() {
+pub fn main() {
let n = test(1, 0, Nil, Nil);
io::println(fmt!("%d", n));
}
pub use a::*;
}
-fn main() {
+pub fn main() {
b::f();
b::g();
}
struct Triple { x: int, y: int, z: int }
-fn main() {
+pub fn main() {
unsafe {
let r = (1,2,3,true,false, Triple {x:5,y:4,z:3});
let p = ptr::addr_of(&r) as *c_void;
visit_tydesc(get_tydesc::<T>(), v);
}
-fn main() {
+pub fn main() {
let v = my_visitor(@{mut types: ~[]});
let vv = v as TyVisitor;
}
}
-fn main() {
+pub fn main() {
let a = A {value: B {v1: 22,
v2: [23, 24, 25],
v3: ~[26, 27, 28],
}
}
-fn main() {
+pub fn main() {
let mut x = Some(23);
{
return &x.pos.x;
}
-fn main() {
+pub fn main() {
}
return &*x;
}
-fn main() {
+pub fn main() {
let three = &3;
log(error, fmt!("%d", *f(three)));
}
assert *a == exp;
}
-fn main() {
+pub fn main() {
}
*x
}
-fn main() {
+pub fn main() {
let p = @22u;
let r = foo(p);
debug!("r=%u", r);
x[0]
}
-fn main() {
+pub fn main() {
let p = ~"hello";
let r = foo(p);
assert r == 'h' as u8;
x[0]
}
-fn main() {
+pub fn main() {
let p = @[22u];
let r = foo(p);
assert r == 22u;
x[0]
}
-fn main() {
+pub fn main() {
let p = [1,2,3,4,5];
assert foo(p) == 1;
}
x[0]
}
-fn main() {
+pub fn main() {
let p = ~[1,2,3,4,5];
let r = foo(p);
assert r == 1;
*x
}
-fn main() {
+pub fn main() {
let p = ~3u;
let r = foo(p);
assert r == 3u;
fn foo<T>(x: &T) -> &uint { produce_static() }
-fn main() {
+pub fn main() {
}
closure_box {cl: move x}
}
-fn main() {
+pub fn main() {
let mut i = 3;
let cl_box = box_it(|| i += 1);
assert i == 3;
add(x, y)
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
add(x, y)
}
-fn main() {
+pub fn main() {
}
\ No newline at end of file
g(a);
}
-fn main() {
+pub fn main() {
}
fn foo(x: &r/uint) -> &r/uint { x }
fn bar(x: &uint) -> uint { *x }
-fn main() {
+pub fn main() {
let p = @3u;
assert bar(foo(p)) == 3;
}
fn wants_same_region(_f: fn(x: &b.int, g: fn(y: &b.int))) {
}
-fn main() {
+pub fn main() {
}
g = f;
}
-fn main() {
+pub fn main() {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut x = 4;
for uint::range(0, 3) |i| {
fn view<T>(x: &r/[T]) -> &r/[T] {x}
-fn main() {
+pub fn main() {
let v = ~[1, 2, 3];
let x = view(v);
let y = view(x);
fn borrow<T>(x: &r/T) -> &r/T {x}
-fn main() {
+pub fn main() {
let x = @3;
loop {
let y = borrow(x);
return &p.x;
}
-fn main() {
+pub fn main() {
let p = @Point {x: 3, y: 4};
let xc = x_coord(p);
assert *xc == 3;
do with |y| { takes_two(x, y) }
}
-fn main() {
+pub fn main() {
assert has_one(&2) == 22;
}
\ No newline at end of file
takes_two(x, y)
}
-fn main() {
+pub fn main() {
assert has_two(&20, &2) == 22;
}
\ No newline at end of file
max(bi, &i)
}
-fn main() {
+pub fn main() {
let g = 21;
let foo = boxed_int { f: &g };
assert with(&foo) == 22;
assert *get(bi) == 22;
}
-fn main() {
+pub fn main() {
let g = 22;
let foo = boxed_int { f: &g };
with(&foo);
return g(fcx);
}
-fn main() {
+pub fn main() {
let ccx = Ccx { x: 0 };
f(&ccx);
}
return g(&fcx);
}
-fn main() {
+pub fn main() {
let ccx = Ccx { x: 0 };
f(&ccx);
}
if cond {a} else {b(ptr)}
}
-fn main() {}
\ No newline at end of file
+pub fn main() {}
\ No newline at end of file
*z
}
-fn main() {
+pub fn main() {
let x = 3u;
assert parameterized(&x) == 3u;
}
fn get_chowder() -> &self/int { return self.chowder; }
}
-fn main() {
+pub fn main() {
let clam = Clam { chowder: &3 };
log(debug, *clam.get_chowder());
clam.get_chowder();
int_wrapper_ctor(&int)
}
-fn main() {
+pub fn main() {
let x = 3;
let y = int_wrapper_ctor(&x);
let mut z : ∫
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut x: int = 3;
let y: &mut int = &mut x;
*y = 5;
(cl.cl)();
}
-fn main() {
+pub fn main() {
let cl_box = box_it(|| debug!("Hello, world!"));
call_static_closure(move cl_box);
}
gc.get_ctxt().v
}
-fn main() {
+pub fn main() {
let ctxt = Ctxt { v: 22 };
let hc = HasCtxt { c: &ctxt };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = [ @[true], ..512 ];
let y = [ 0, ..1 ];
error!("%?", x);
const foo: int = 4 >> 1;
enum bs { thing = foo }
-fn main() { assert(thing as int == foo); }
+pub fn main() { assert(thing as int == foo); }
}
}
-fn main() {
+pub fn main() {
let i = @mut 0;
// Even though these look like copies, they are guaranteed not to be
{
r: r
}
-fn main() {
+pub fn main() {
unsafe {
let i1 = ~0;
let i1p = cast::reinterpret_cast(&i1);
r: r
}
-fn main() {
+pub fn main() {
unsafe {
let i1 = ~0xA;
let i1p = cast::reinterpret_cast(&i1);
r: R
}
-fn main() {
+pub fn main() {
unsafe {
let i1 = ~0xA;
let i1p = cast::reinterpret_cast(&i1);
}
}
-fn main() {
+pub fn main() {
let my_total = @@mut 10;
{ let pt = move shrinky_pointer(my_total); assert (pt.look_at() == 10); }
log(error, fmt!("my_total = %d", **my_total));
}
}
-fn main() {
+pub fn main() {
let box = @mut 10;
fn dec_box(&&i: @mut int) { *i -= 1; }
fn sink(res: option<close_res>) { }
-fn main() {
+pub fn main() {
let c = @mut true;
sink(none);
sink(some(close_res(c)));
if i == 3u { my_err(~"I don't like three"); } else { return 42; }
}
-fn main() { okay(4u); }
+pub fn main() { okay(4u); }
return ~"bye";
}
-fn main() {
+pub fn main() {
let mut last = 0;
for vec::all(~[1, 2, 3, 4, 5, 6, 7]) |e| {
last = *e;
fn f<T: Copy>() -> option<T> { return none; }
-fn main() { f::<int>(); }
+pub fn main() { f::<int>(); }
fn f() { let x: () = (); return x; }
-fn main() { let x = f(); }
+pub fn main() { let x = f(); }
pub fn start_task(id: task_id, f: closure);
}
-fn main() {
+pub fn main() {
unsafe {
let (po, ch) = stream();
let parent_sched_id = rustrt::rust_get_sched_id();
pub fn bar() { assert (a::foo() == 1); }
}
-fn main() { c::bar(); }
+pub fn main() { c::bar(); }
}
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {
+pub fn main() {
for uint::range(0u, 16u) |_i| {
task::spawn_unlinked(|| iloop() );
}
}
}
-fn main() {
+pub fn main() {
let (p, c) = stream();
do task::spawn() {
let (ctrl_port, ctrl_chan) = stream();
c.send(ctrl_chan);
}
-fn main() { }
+pub fn main() { }
}
}
-fn main() {
+pub fn main() {
let (_po, ch) = pipes::stream();
ch.send(foo(42, 'c'));
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { test05(); }
+pub fn main() { test05(); }
fn mk_counter<A:Copy>() -> fn~(A) -> (A,uint) {
// The only reason that the counter is generic is so that it closes
// xfail-fast
#[legacy_modes];
-fn main() { test05(); }
+pub fn main() { test05(); }
struct Pair<A,B> { a: A, b: B }
return f(22u);
}
-fn main() {
+pub fn main() {
let y = test(fn~(x: uint) -> uint { return 4u * x; });
assert y == 88u;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { test05(); }
+pub fn main() { test05(); }
fn test05_start(&&f: fn~(int)) {
f(22);
-fn main() {
+pub fn main() {
assert (~"hello" < ~"hellr");
assert (~"hello " > ~"hello");
assert (~"hello" != ~"there");
enum t<T> { none, some(T), }
-fn main() { let x = 10; let x = x + 20; assert (x == 30); foo(~[]); }
+pub fn main() { let x = 10; let x = x + 20; assert (x == 30); foo(~[]); }
struct X { sp: Span, path: path }
-fn main() {
+pub fn main() {
let sp: Span = Span {lo: 57451u, hi: 57542u, expanded_from: os_none};
let t: @ty = @Spanned { data: 3u, span: sp };
let p_: Path_ = Path_ { global: true, idents: ~[~"hi"], types: ~[t] };
// pp-exact
-fn main() { io::println("Hello World"); }
+pub fn main() { io::println("Hello World"); }
// Testing shifts for various combinations of integers
// Issue #1570
-fn main() {
+pub fn main() {
test_misc();
test_expr();
test_const();
// except according to those terms.
enum test { thing = -5 >> 1u }
-fn main() {
+pub fn main() {
assert(thing as int == -3);
}
enum opt<T> { none, }
-fn main() {
+pub fn main() {
let x = none::<int>;
match x { none::<int> => { debug!("hello world"); } }
}
enum clam<T> { a(T), }
-fn main() { let c = a(2); match c { a::<int>(_) => { } } }
+pub fn main() { let c = a(2); match c { a::<int>(_) => { } } }
enum clam<T> { a(T), }
-fn main() { }
+pub fn main() { }
-fn main() { let mut n; n = 1; log(debug, n); }
+pub fn main() { let mut n; n = 1; log(debug, n); }
}
}
-fn main() {
+pub fn main() {
let v: ~[clam<int>] = ~[b::<int>, b::<int>, a::<int>(42, 17)];
uhoh::<int>(v);
}
log(debug, n);
}
-fn main() {
+pub fn main() {
task::spawn(|| x(~"hello from first spawned fn", 65) );
task::spawn(|| x(~"hello from second spawned fn", 66) );
task::spawn(|| x(~"hello from third spawned fn", 67) );
assert (ip == ~"localhost");
}
-fn main() {
+pub fn main() {
let (p, ch) = stream::<int>();
task::spawn(|| iotask(&ch, ~"localhost") );
}
extern mod std;
-fn main() {
+pub fn main() {
task::spawn(|| child(10) );
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { task::spawn(|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); }
+pub fn main() { task::spawn(|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) ); }
fn child(&&args: (int, int, int, int, int, int, int, int, int)) {
let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
// Issue #2040
-fn main() {
+pub fn main() {
let foo = 1;
assert ptr::addr_of(&foo) == ptr::addr_of(&foo);
}
use io::WriterUtil;
use std::tempfile;
-fn main() {
+pub fn main() {
let dir = option::unwrap(tempfile::mkdtemp(&Path("."), ""));
let path = dir.with_filename("file");
use mycore::num;
-fn main() {
+pub fn main() {
let _1:float = num::Num2::from_int2(1i);
}
use mycore::num;
-fn main() {
+pub fn main() {
let _1:float = num::Num2::from_int2(1i);
}
}
}
-fn main() {
+pub fn main() {
assert 10u.plus() == 30;
assert (~"hi").plus() == 200;
fn read_int() -> int { 22 }
}
-fn main() {
+pub fn main() {
let d = FromThinAir { dummy: () };
let i: int = Deserializable::deserialize(&d);
assert i == 22;
}
}
-fn main() {
+pub fn main() {
let v: @[int] = seq_range(0, 10);
assert v == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
use static_methods_crate::read;
use readMaybeRenamed = static_methods_crate::read::readMaybe;
-fn main() {
+pub fn main() {
let result: int = read(~"5");
assert result == 5;
assert readMaybeRenamed(~"false") == Some(false);
}
}
-fn main() {
+pub fn main() {
let x: int = a::Foo::foo();
let y: uint = a::Foo::foo();
assert x == 3;
pure fn to_float(&self) -> float { *self }
}
-fn main() {
+pub fn main() {
let _: float = Number::from(0.0f);
}
assert (b == ~"ABCabcABC");
}
-fn main() { test1(); test2(); }
+pub fn main() { test1(); test2(); }
// -*- rust -*-
-fn main() {
+pub fn main() {
let a: ~str = ~"hello";
let b: ~str = ~"world";
let s: ~str = a + b;
-fn main() {
+pub fn main() {
let mut s = ~"a";
s += ~"b";
assert (s[0] == 'a' as u8);
-fn main() {
+pub fn main() {
let s = ~"hello";
let c: u8 = s[4];
log(debug, c);
// -*- rust -*-
extern mod std;
-fn main() {
+pub fn main() {
let a: ~str = ~"this \
is a test";
let b: ~str =
extern mod std;
-fn main() {
+pub fn main() {
// Make sure we properly handle repeated self-appends.
let mut a: ~str = ~"A";
let mut i = 20;
struct Foo(int);
-fn main() {
+pub fn main() {
let x: Foo = Foo(2);
assert *x == 2;
}
extern mod struct_destructuring_cross_crate;
-fn main() {
+pub fn main() {
let x = struct_destructuring_cross_crate::S { x: 1, y: 2 };
let struct_destructuring_cross_crate::S { x: a, y: b } = x;
assert a == 1;
x: &int
}
-fn main() {
+pub fn main() {
let f = Foo { x: @3 };
assert *f.x == 3;
}
}
}
-fn main() {
+pub fn main() {
let x = Bar { a: 2, b: 3 };
}
}
}
-fn main() {
+pub fn main() {
let x = Bar { x: 1, y: 2 };
f(&x);
let y = Baz { x: 1.0, y: 2.0 };
}
}
-fn main() {
+pub fn main() {
let _z = foo { x: ~"Hello" };
}
y: int,
}
-fn main() {
+pub fn main() {
let a = Foo { x: 1, y: 2 };
match a {
Foo { x: x, y: y } => io::println(fmt!("yes, %d, %d", x, y))
fn test2() {
}
-fn main() {
+pub fn main() {
test1();
test2();
}
pure fn ne(&self, other: &foo) -> bool { !(*self).eq(other) }
}
-fn main() {
+pub fn main() {
let a = (1, 2, 3);
let b = (1, 2, 3);
assert (a == b);
}
}
-fn main() {
+pub fn main() {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let f = 1 as *libc::FILE;
log(debug, f as int);
log(debug, f as uint);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut x = 3; let mut y = 7;
x <-> y; assert (x == 7); assert (y == 3);
}
fn swap<T>(v: &[mut T], i: int, j: int) { v[i] <-> v[j]; }
-fn main() {
+pub fn main() {
let a: ~[mut int] = ~[mut 0, 1, 2, 3, 4, 5, 6];
swap(a, 2, 4);
assert (a[2] == 4);
assert (actual == expected);
}
-fn main() {
+pub fn main() {
test(fmt!("hello %d friends and %s things", 10, ~"formatted"),
~"hello 10 friends and formatted things");
// except according to those terms.
-fn main() {
+pub fn main() {
let asdf_fdsa = ~"<.<";
assert (concat_idents!(asd, f_f, dsa) == ~"<.<");
// except according to those terms.
// xfail-test
-fn main() {
+pub fn main() {
let s = shell!( uname -a );
log(debug, s);
}
}
}
-fn main() {
+pub fn main() {
assert(line!() == 21);
assert(col!() == 11);
assert(file!().to_owned().ends_with(~"syntax-extension-source-utils.rs"));
return (p & 7u) == 0u;
}
-fn main() {
+pub fn main() {
let x = mk_rec();
assert is_8_byte_aligned(x.t);
}
}
}
-fn main() {
+pub fn main() {
let x = mk_rec(22u64, 23u64);
assert is_aligned(8u, x.tA);
assert variant_data_is_aligned(8u, x.tA);
t: a_tag
};
-fn main() {
+pub fn main() {
let x = {c8: 22u8, t: a_tag(44u64)};
let y = fmt!("%?", x);
debug!("y = %s", y);
return (p & 7u64) == 0u64;
}
-fn main() {
+pub fn main() {
let x = mk_rec();
assert is_8_byte_aligned(x.t);
}
white = 0xFFFFFF,
}
-fn main() {
+pub fn main() {
let act = fmt!("%?", red);
io::println(act);
assert ~"red" == act;
pub enum marshall { northrup, overton }
}
-fn main() {
+pub fn main() {
let _pettygrove: burnside = couch;
let _quimby: everett = flanders;
let _raleigh: irving = johnson;
fn baz() { zed(nil); }
}
-fn main() { }
+pub fn main() { }
pure fn ne(&self, other: &color) -> bool { !(*self).eq(other) }
}
-fn main() {
+pub fn main() {
test_color(red, 0xff0000, ~"red");
test_color(green, 0x00ff00, ~"green");
test_color(blue, 0x0000ff, ~"blue");
fn f() { let x = red(1, 2); let y = green; assert (x != y); }
-fn main() { f(); }
+pub fn main() { f(); }
// use of tail calls causes arg slot leaks, issue #160.
fn inner(dummy: ~str, b: bool) { if b { return inner(dummy, false); } }
-fn main() { inner(~"hi", true); }
+pub fn main() { inner(~"hi", true); }
// -*- rust -*-
fn checktrue(rs: bool) -> bool { assert (rs); return true; }
-fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
+pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
fn evenk(n: int, k: extern fn(bool) -> bool) -> bool {
debug!("evenk");
// -*- rust -*-
-fn main() { assert (even(42)); assert (odd(45)); }
+pub fn main() { assert (even(42)); assert (odd(45)); }
fn even(n: int) -> bool { if n == 0 { return true; } else { return odd(n - 1); } }
use pipes::Chan;
use pipes::Port;
-fn main() { test05(); }
+pub fn main() { test05(); }
fn test05_start(ch : Chan<int>) {
ch.send(10);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { test00(); }
+pub fn main() { test00(); }
fn start() { debug!("Started / Finished task."); }
log(error, move b);
}
-fn main() {
+pub fn main() {
let (p, ch) = pipes::stream();
let child = task::spawn(|move ch| start(ch) );
c.send(move ch);
}
-fn main() {
+pub fn main() {
let (p, ch) = pipes::stream();
let child = task::spawn(|move ch| start(ch) );
let c = p.recv();
extern mod std;
-fn main() { test00(); }
+pub fn main() { test00(); }
fn start(&&task_number: int) { debug!("Started / Finished task."); }
while i < number_of_messages { c.send(start + i); i += 1; }
}
-fn main() {
+pub fn main() {
debug!("Check that we don't deadlock.");
let (p, ch) = pipes::stream();
task::try(|move ch| start(ch, 0, 10) );
// xfail-fast
#[legacy_modes];
-fn main() {
+pub fn main() {
let po = pipes::PortSet();
// Spawn 10 tasks each sending us back one int.
}
}
-fn main() {
+pub fn main() {
// Spawn a task that sends us back messages. The parent task
// is likely to terminate before the child completes, so from
// the child's point of view the receiver may die. We should
assert (i == 10);
}
-fn main() {
+pub fn main() {
test_rec();
test_vec();
test_str();
fn f() {
}
-fn main() {
+pub fn main() {
task::spawn(|| f() );
}
\ No newline at end of file
use pipes::send;
use pipes::recv;
-fn main() { debug!("===== WITHOUT THREADS ====="); test00(); }
+pub fn main() { debug!("===== WITHOUT THREADS ====="); test00(); }
fn test00_start(ch: Chan<int>, message: int, count: int) {
debug!("Starting test00_start");
use pipes::send;
-fn main() { test00(); }
+pub fn main() { test00(); }
fn test00() {
let mut r: int = 0;
extern mod std;
-fn main() { test00(); }
+pub fn main() { test00(); }
fn test00() {
let r: int = 0;
use pipes::Chan;
use pipes::recv;
-fn main() { test00(); }
+pub fn main() { test00(); }
fn test00() {
let mut r: int = 0;
extern mod std;
-fn main() { test00(); }
+pub fn main() { test00(); }
fn test00_start(c: pipes::Chan<int>, start: int, number_of_messages: int) {
let mut i: int = 0;
extern mod std;
-fn main() { test00(); }
+pub fn main() { test00(); }
fn test00_start(c: pipes::Chan<int>, number_of_messages: int) {
let mut i: int = 0;
// rustboot can't transmit nils across channels because they don't have
// any size, but rustc currently can because they do have size. Whether
// or not this is desirable I don't know, but here's a regression test.
-fn main() {
+pub fn main() {
let (po, ch) = pipes::stream();
ch.send(());
let n: () = po.recv();
join(t);
}
-fn main() {
+pub fn main() {
join(joinable(supervisor));
}
task::try(supervised);
}
-fn main() {
+pub fn main() {
task::spawn_unlinked(supervisor)
}
// except according to those terms.
extern mod std;
-fn main() {
+pub fn main() {
task::spawn(|| child(~"Hello") );
}
use core::pipes::*;
-fn main() {
+pub fn main() {
let (p, ch) = stream::<uint>();
let x = ~1;
task::try(|| g() );
}
-fn main() {
+pub fn main() {
test_break();
test_cont();
test_ret();
// Building as a test runner means that a synthetic main will be run,
// not ours
-fn main() { die!(); }
+pub fn main() { die!(); }
extern mod std;
-fn main() {
+pub fn main() {
let mut i = 10;
while i > 0 { task::spawn({let i = i; || child(i)}); i = i - 1; }
debug!("main thread exiting");
// Test that the task fails after hitting the recursion limit, but
// that it doesn't bring down the whole proc
-fn main() {
+pub fn main() {
do task::spawn_unlinked {
fn f() { f() };
f();
fn create() -> my_connection { () }
}
-fn main() {
+pub fn main() {
let factory = ();
let connection = factory.create();
let result = connection.read();
fn foo<T: to_str>(x: T) -> ~str { x.to_str() }
-fn main() {
+pub fn main() {
let t1 = Tree(@TreeR{mut left: None,
mut right: None,
val: 1 as to_str });
fn bar();
}
-fn main() {}
+pub fn main() {}
x.map(|_e| _e.to_str() )
}
-fn main() {
+pub fn main() {
assert foo(~[1]) == ~[~"hi"];
assert bar::<int, ~[int]>(~[4, 5]) == ~[~"4", ~"5"];
assert bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"];
assert a.h() == 30;
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
f(a);
}
assert a.h() == 30;
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
f(a);
}
assert a.h() == 30;
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
f(a);
}
a.f()
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
assert gg(a) == 10;
}
a.f()
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
assert gg(a) == 10;
}
fn g() -> int { 20 }
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
let afoo = a as &Foo;
let abar = a as &Bar;
fn g() -> int { 20 }
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
let afoo = a as &Foo;
let abar = a as &Bar;
fn g() -> int { self.f() }
}
-fn main() {
+pub fn main() {
let a = &aux::A { x: 3 };
assert a.g() == 10;
}
fn g() -> int { self.f() }
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
assert a.g() == 10;
}
assert x.d() == 40;
}
-fn main() {
+pub fn main() {
let value = &S { bogus: () };
f(value);
}
\ No newline at end of file
assert x.c() == 30;
}
-fn main() {
+pub fn main() {
f(&S { bogus: () })
}
\ No newline at end of file
assert z.c() == 30;
}
-fn main() {
+pub fn main() {
let s = &S { bogus: () };
f(s, s, s);
}
\ No newline at end of file
fn greater_than_one<T:NumExt>(n: &T) -> bool { *n > from_int(1) }
fn greater_than_one_float<T:FloatExt>(n: &T) -> bool { *n > from_int(1) }
-fn main() {}
+pub fn main() {}
n.gt(&from_int(1))
}
-fn main() {}
+pub fn main() {}
*n > from_int(1)
}
-fn main() {}
+pub fn main() {}
fn test_float_ext<T:FloatExt>(n: T) { io::println(fmt!("%?", n < n)) }
-fn main() {
+pub fn main() {
test_float_ext(1f32);
}
fn num_eq_one<T:NumExt>(n: T) { io::println(fmt!("%?", n == from_int(1))) }
-fn main() {
+pub fn main() {
num_eq_one(1f32); // you need to actually use the function to trigger the ICE
}
\ No newline at end of file
from_int(1)
}
-fn main() {
+pub fn main() {
num_eq_one::<int>(); // you need to actually use the function to trigger the ICE
}
pure fn mi(v: int) -> MyInt { MyInt { val: v } }
-fn main() {
+pub fn main() {
let (x, y, z) = (mi(3), mi(5), mi(3));
assert x != y;
assert x == z;
pure fn mi(v: int) -> MyInt { MyInt { val: v } }
-fn main() {
+pub fn main() {
let (x, y) = (mi(3), mi(5));
let (a, b, c) = f(x, y);
assert a == mi(8);
pure fn mi(v: int) -> MyInt { MyInt { val: v } }
-fn main() {
+pub fn main() {
let (x, y) = (mi(3), mi(5));
let (a, b, c) = f(x, y);
assert a == mi(8);
}
}
-fn main() {
+pub fn main() {
let s = S { x: 1 };
s.g();
}
a.g()
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
assert ff(a) == 10;
assert gg(a) == 20;
fn greater_than_one<T:NumExt>() -> T { MyNum::from_int(1) }
-fn main() {
+pub fn main() {
let v: S = greater_than_one();
assert v.v == 1;
}
fn greater_than_one<T:NumExt>() -> T { MyNum::from_int(1) }
-fn main() {
+pub fn main() {
let v: S = greater_than_one();
assert v.v == 1;
}
pure fn mi(v: int) -> MyInt { MyInt { val: v } }
-fn main() {
+pub fn main() {
let (x, y) = (mi(3), mi(5));
let z = f(x, y);
assert z.val == 8
fn mi(v: int) -> MyInt { MyInt { val: v } }
-fn main() {
+pub fn main() {
let (x, y) = (mi(3), mi(5));
let z = f(x, y);
assert z.val == 13;
assert x.f() == 10;
}
-fn main() {
+pub fn main() {
f(&0)
}
\ No newline at end of file
assert a.h() == 30;
}
-fn main() {
+pub fn main() {
let a = &A { x: 3 };
f(a);
}
}
}
-fn main() {
+pub fn main() {
let a = A { x: 3 };
let b = (&a) as &Foo;
assert b.f() == 3;
}
}
-fn main() {
+pub fn main() {
let f: base::Foo = base::HasNew::new::<base::Foo, base::Foo>();
let b: base::Bar = base::HasNew::new::<base::Bar, base::Bar>();
}
}
}
-fn main() {
+pub fn main() {
assert 1.to_str() == ~"1";
assert (~[2, 3, 4]).to_str() == ~"[2, 3, 4]";
fn bar() { }
}
-fn main() {
+pub fn main() {
let s = S {
name: 0
};
impl Baz: Foo {
}
-fn main() {
+pub fn main() {
let q = Quux;
assert q.bar() == ~"test";
}
}
}
-fn main() {
+pub fn main() {
assert 5.meow();
}
}
}
-fn main() {
+pub fn main() {
assert 5.meow();
}
This is about the simplest program that can successfully send a
message.
*/
-fn main() {
+pub fn main() {
let (po, ch) = pipes::stream();
ch.send(42);
let r = po.recv();
even(v);
}
-fn main() {
+pub fn main() {
test();
}
assert (b == y);
}
-fn main() {
+pub fn main() {
let p: point = (10, 20);
let (a, b) = p;
assert (a == 10);
struct Foo(int, int);
-fn main() {
+pub fn main() {
let x = Foo(1, 2);
io::println(fmt!("%?", x));
}
struct Foo(int, int);
-fn main() {
+pub fn main() {
let x = Foo(1, 2);
let Foo(y, z) = x;
io::println(fmt!("%d %d", y, z));
struct Foo(int, int);
-fn main() {
+pub fn main() {
let x = Foo(1, 2);
match x {
Foo(a, b) => {
struct Foo(int, int, int);
-fn main() {
+pub fn main() {
}
}
}
-fn main() { }
+pub fn main() { }
fn a(a: A) -> int { return a.a; }
-fn main() { let x: A = A {a: 1}; assert (a(x) == 1); }
+pub fn main() { let x: A = A {a: 1}; assert (a(x) == 1); }
}
}
-fn main() {
+pub fn main() {
p_foo(r(10));
p_foo(@r(10));
type lteq<T> = extern fn(T) -> bool;
-fn main() { }
+pub fn main() { }
range(0u, 256u, |_i| { let bucket: ~[T] = ~[]; } )
}
-fn main() { }
+pub fn main() { }
fn g(a: *int) -> *int { let b = f(a); return b; }
-fn main() { return; }
+pub fn main() { return; }
use sys::rustrt::size_of;
extern mod std;
-fn main() {
+pub fn main() {
assert (size_of::<u8>() == 1 as uint);
assert (size_of::<u32>() == 4 as uint);
assert (size_of::<char>() == 4 as uint);
// except according to those terms.
use io::ReaderUtil;
-fn main() {
+pub fn main() {
let mut x: bool = false;
// this line breaks it
vec::rusti::move_val_init(&mut x, false);
}
}
-fn main() {
+pub fn main() {
assert Equal::isEq(cyan, cyan);
assert Equal::isEq(magenta, magenta);
assert !Equal::isEq(cyan, yellow);
}
}
-fn main() {
+pub fn main() {
assert cyan.isEq(cyan);
assert magenta.isEq(magenta);
assert !cyan.isEq(yellow);
if true { match x { _ => { y = x; } } } else { }
}
-fn main() {
+pub fn main() {
let x = 10;
let mut y = 11;
if true { while false { y = x; } } else { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let x = 10, y = 20; let z = x + y; assert (z == 30); }
+pub fn main() { let x = 10, y = 20; let z = x + y; assert (z == 30); }
// -*- rust -*-
-fn main() {
+pub fn main() {
let mut word: u32 = 200000u32;
word = word - 1u32;
assert (word == 199999u32);
// These constants were chosen because they aren't used anywhere
// in the rest of the generated code so they're easily grep-able.
-fn main() {
+pub fn main() {
let mut x: u8 = 19u8; // 0x13
let mut y: u8 = 35u8; // 0x23
// -*- rust -*-
-fn main() {
+pub fn main() {
let mut x: u8 = 12u8;
let y: u8 = 12u8;
x = x + 1u8;
// -*- rust -*-
-fn main() { let x: uint = 10 as uint; }
+pub fn main() { let x: uint = 10 as uint; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let a = 1;
let a_neg: i8 = -a;
log(error, a_neg);
}
}
-fn main() { null::<int>(); }
+pub fn main() { null::<int>(); }
}
}
-fn main()
+pub fn main()
{
let v = empty_pointy();
v.a = p(v);
}
}
-fn main()
+pub fn main()
{
let v = empty_pointy();
v.a = p(v);
_ => { }
}
}
-fn main() { }
\ No newline at end of file
+pub fn main() { }
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~mut 1;
// Should be a copy
let mut j;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~1;
let mut j = ~2;
// Should drop the previous value of j
t1
}
-fn main() {
+pub fn main() {
let t = f(~100);
assert t == ~100;
let t = f(~@~[100]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut i;
i = ~1;
assert *i == 1;
struct J { j: int }
-fn main() {
+pub fn main() {
let i = ~J {
j: 100
};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~~[100];
assert i[0] == 100;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
assert i == ~100;
assert i < ~101;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
enum t { t1(int), t2(int), }
let x = ~t1(10);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
unsafe {
let i = ~@1;
let j = ~@2;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
~100;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~mut 1;
// Should be a copy
let j = copy i;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~1;
let j = i;
assert *j == 1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = move ~100;
assert *i == 100;
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
let j = move i;
assert *j == 100;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let _: ~int;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
assert *i == 100;
}
\ No newline at end of file
struct Foo { a: int, b: int }
-fn main() {
+pub fn main() {
let ~Foo{a, b} = ~Foo{a: 100, b: 200};
assert a + b == 300;
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = ~~[0,0,0,0,0];
}
assert *i == 100;
}
-fn main() {
+pub fn main() {
let i = ~100;
f(move i);
}
\ No newline at end of file
*i = ~200;
}
-fn main() {
+pub fn main() {
let mut i = ~100;
f(&mut i);
assert *i == 200;
assert *i == 100;
}
-fn main() {
+pub fn main() {
f(~100);
let i = ~100;
f(i);
~100
}
-fn main() {
+pub fn main() {
assert f() == ~100;
}
\ No newline at end of file
fn f<T: Copy>(x: ~T) {
let _x2 = x;
}
-fn main() { }
+pub fn main() { }
} == 10;
}
-fn main() {
+pub fn main() {
test1();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let a = ~[~mut 10];
let b = copy a;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
assert (~[~100])[0] == ~100;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
}
\ No newline at end of file
g(i, j);
}
-fn main() {
+pub fn main() {
sendable();
copyable();
noncopyable();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
log(error, i);
}
\ No newline at end of file
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
let j = ~200;
let j = move i;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut i;
i = move ~100;
assert *i == 100;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~100;
let mut j;
j = move i;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let i = ~mut 0;
*i = 1;
assert *i == 1;
}
}
-fn main() {
+pub fn main() {
let x = ~Bar { x: 10 };
let y = x as ~Foo;
let z = copy y;
enum bar { u(~Foo), w(int), }
-fn main() {
+pub fn main() {
assert (match u(~Foo{a: 10, b: 40u}) {
u(~Foo{a: a, b: b}) => { a + (b as int) }
_ => { 66 }
enum bar { u(~int), w(int), }
-fn main() {
+pub fn main() {
assert match u(~10) {
u(a) => {
log(error, a);
}
}
-fn main() {
+pub fn main() {
simple();
}
}
}
-fn main() {
+pub fn main() {
let i = @mut 0;
{
let j = ~r(i);
struct X { x: int }
-fn main() {
+pub fn main() {
let x = ~X {x: 1};
let bar = x;
assert bar.x == 1;
c.send(~i);
}
-fn main() {
+pub fn main() {
let (p, ch) = stream();
let ch = SharedChan(ch);
let n = 100u;
use core::pipes::*;
-fn main() {
+pub fn main() {
let (p, c) = stream();
c.send(~100);
let v = p.recv();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut i = ~100;
let mut j = ~200;
i <-> j;
struct Foo;
-fn main() {
+pub fn main() {
let x: Foo = Foo;
match x {
Foo => { io::println("hi"); }
// -*- rust -*-
fn f(u: ()) { return u; }
-fn main() {
+pub fn main() {
let u1: () = ();
let mut u2: () = f(u1);
u2 = ();
fn called(f: fn(&int)) {
}
-fn main() {
+pub fn main() {
called(good);
}
fn call_id_3() { id(return) && id(return); }
-fn main() {
+pub fn main() {
}
}
}
-fn main() {}
+pub fn main() {}
}
}
-fn main() {
+pub fn main() {
}
f();
}
-fn main() {
+pub fn main() {
return;
}
}
}
-fn main() {
+pub fn main() {
f(&3);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x = ~1;
let lam_move = fn@(move x) { };
lam_move();
// Issue Name: Unused move causes a crash
// Abstract: zero-fill to block after drop
-fn main()
+pub fn main()
{
let y = ~1;
move y;
die!();
}
-fn main() {
+pub fn main() {
task::spawn_unlinked(f);
}
die!();
}
-fn main() {
+pub fn main() {
let (p, c) = stream();
let c = SharedChan(c);
task::spawn_unlinked(|| f(c.clone()) );
die!();
}
-fn main() {
+pub fn main() {
task::spawn_unlinked(f);
}
die!();
}
-fn main() {
+pub fn main() {
task::spawn_unlinked(f);
}
// Issue #1706
extern mod stdlib(name="std");
-fn main() {}
+pub fn main() {}
pub fn y() -> int { return 1; }
}
-fn main() { foo::x(); bar::y(); }
+pub fn main() { foo::x(); bar::y(); }
}
}
-fn main() {
+pub fn main() {
b::f();
}
impl int: foo { fn foo() -> int { 10 } }
trait foo { fn foo() -> int; }
-fn main() {}
\ No newline at end of file
+pub fn main() {}
\ No newline at end of file
enum myoption<T> { none, some(T), }
-fn main() { log(debug, 5); }
+pub fn main() { log(debug, 5); }
enum myoption<T> { none, some(T), }
-fn main() { log(debug, 5); }
+pub fn main() { log(debug, 5); }
pub use x = core::str;
}
-fn main() { }
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let yen: char = 'Â¥'; // 0xa5
let c_cedilla: char = 'ç'; // 0xe7
let thorn: char = 'þ'; // 0xfe
extern mod std;
-fn main() {
+pub fn main() {
// Chars of 1, 2, 3, and 4 bytes
let chs: ~[char] = ~['e', 'é', '€', 0x10000 as char];
let s: ~str = str::from_chars(chs);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let ε = 0.00001;
let Î = 3.14;
let लंच = Π* Π+ 1.54;
fn boldly_go(_crew_member: crew_of_enterprise_d, _where: ~str) { }
-fn main() { boldly_go(worf, ~"where no one has gone before"); }
+pub fn main() { boldly_go(worf, ~"where no one has gone before"); }
Baz { y: int }
}
-fn main() { }
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let a: ~[int] = ~[1, 2, 3, 4, 5];
let b: ~[int] = ~[6, 7, 8, 9, 0];
let v: ~[int] = a + b;
struct Pair { x: int, y: int }
-fn main() {
+pub fn main() {
// This just tests whether the vec leaks its members.
let pvec: ~[@Pair] =
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let x: [int*4] = [1, 2, 3, 4];
io::println(fmt!("%d", x[0]));
}
-fn main() {
+pub fn main() {
let mut v = ~[1];
v += ~[2];
v += ~[3];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let a = ~[1, 2, 3, 4, 5];
let mut b = ~[copy a, copy a];
b = b + b; // FIXME(#3387)---can't write b += b
-fn main() {
+pub fn main() {
let mut later: ~[int];
if true { later = ~[1]; } else { later = ~[2]; }
log(debug, later[0]);
-fn main() {
+pub fn main() {
let x = @[1, 2, 3];
match x {
[2, .._] => ::core::util::unreachable(),
-fn main() {
+pub fn main() {
let x = &[1, 2, 3, 4, 5];
if !x.is_empty() {
let el = match x {
}
}
-fn main() {
+pub fn main() {
let x = [1, 2, 3, 4, 5];
match x {
[a, b, c, d, e, f] => {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let mut v = ~[1, 2, 3]; v.push(1); }
+pub fn main() { let mut v = ~[1, 2, 3]; v.push(1); }
}
}
-fn main() { test_heap_to_heap(); test_stack_to_heap(); test_loop(); }
+pub fn main() { test_heap_to_heap(); test_stack_to_heap(); test_loop(); }
}
}
-fn main() {
+pub fn main() {
let x = @mut 0;
{
let l = &[foo(x)];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let v = ~[1,2,3,4,5];
let v2 = vec::slice(v, 1, 3);
assert (v2[0] == 2);
string: ~str
}
-fn main() {
+pub fn main() {
let x = [
Foo { string: ~"foo" },
Foo { string: ~"bar" },
// Issue #2482.
-fn main() {
+pub fn main() {
let v1: ~[int] = ~[10, 20, 30,];
let v2: ~[int] = ~[10, 20, 30];
assert (v1[2] == v2[2]);
// -*- rust -*-
-fn main() {
+pub fn main() {
let v: ~[int] = ~[10, 20];
assert (v[0] == 10);
assert (v[1] == 20);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { let quux: @~[uint] = @~[]; }
+pub fn main() { let quux: @~[uint] = @~[]; }
pub fn malloc(size: int) -> *u8;
}
-fn main() {
+pub fn main() {
}
fn evil_lincoln() { let evil = move debug!("lincoln"); }
-fn main() {
+pub fn main() {
strange();
funny();
what();
// except according to those terms.
// Issue #825: Should recheck the loop contition after continuing
-fn main() {
+pub fn main() {
let mut i = 1;
while i > 0 {
assert (i > 0);
-fn main() { let x: int = 10; while x == 10 && x == 11 { let y = 0xf00; } }
+pub fn main() { let x: int = 10; while x == 10 && x == 11 { let y = 0xf00; } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut y: int = 42;
let mut z: int = 42;
return b(s);
}
-fn main() {
+pub fn main() {
let mut i = 0;
// -*- rust -*-
-fn main() {
+pub fn main() {
let mut i: int = 90;
while i < 100 {
log(debug, i);
-fn main() {
+pub fn main() {
let mut x: int = 10;
let mut y: int = 0;
while y < x { log(debug, y); debug!("hello"); y = y + 1; }
fn f(p: &mut Point) { p.z = 13; }
-fn main() {
+pub fn main() {
let mut x: Point = Point {x: 10, y: 11, mut z: 12};
f(&mut x);
assert (x.z == 13);
#[cfg(target_os = "win32")]
-fn main() {
+pub fn main() {
unsafe {
let expected = 1234u;
kernel32::SetLastError(expected);
#[cfg(target_os = "macos")]
#[cfg(target_os = "linux")]
#[cfg(target_os = "freebsd")]
-fn main() { }
+pub fn main() { }
#[cfg(target_os = "win32")]
-fn main() {
+pub fn main() {
let heap = unsafe { kernel32::GetProcessHeap() };
let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) };
assert mem != 0u;
#[cfg(target_os = "macos")]
#[cfg(target_os = "linux")]
#[cfg(target_os = "freebsd")]
-fn main() { }
+pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut result = None;
task::task().future_result(|+r| { result = Some(move r); }).spawn(child);
error!("1");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut result = None;
task::task().future_result(|+r| { result = Some(move r); }).spawn(child);
error!("1");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() {
+pub fn main() {
let mut i: int = 0;
while i < 100 { i = i + 1; log(error, i); task::yield(); }
}
return r;
}
-fn main() {
+pub fn main() {
let a = 'a' as u8, j = 'j' as u8, k = 1u, l = 10u;
let chars = enum_chars(a, j);
let ints = enum_uints(k, l);
projects / rust.git / commitdiff