type box[T] = tup(@T); fn unbox[T](box[T] b) -> T { ret b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(foo); log "see what's in our box"; check (unbox[int](bfoo) == foo); } type box[T] = tup(@T); fn unbox[T](box[T] b) -> T { ret *b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(@foo); log "see what's in our box"; check (unbox[int](bfoo) == foo); } type box[T] = tup(@T); fn unbox[T](&box[T] b) -> T { ret *b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(@foo); log "see what's in our box"; check (unbox[int](bfoo) == foo); } type box[T] = tup(@T); fn unbox[T](&box[T] b) -> T { ret *b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(@foo); log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box[T] = tup(@T); fn unbox[T](&box[T] b) -> T { ret *b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(@foo); log "see what's in our box"; check (unbox[int](bfoo) == foo); } type box[T] = tup(@T); fn unbox[T](&box[T] b) -> T { ret *b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(@foo); log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box[T] = tup(@T); fn unbox[T](&box[T] b) -> T { ret *b._0; } fn main() { let int foo = 17; let box[int] bfoo = tup(@foo); log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box[T] = rec(@T c); fn unbox[T](&box[T] b) -> T { ret *b.c; } fn main() { let int foo = 17; let box[int] bfoo = rec(c=@foo); log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box[T] = {c: @T}; fn unbox[T](b: &box[T]) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box[int] = {c: @foo}; log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box[T] = {c: @T}; fn unbox[T](b: &box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box<T> = {c: @T}; fn unbox<T>(b: &box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox[int](bfoo) == foo); } type box<T> = {c: @T}; fn unbox<T>(b: &box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox::<int>(bfoo) == foo); } type box<T> = {c: @T}; fn unbox<@T>(b: &box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox::<int>(bfoo) == foo); } type box<T> = {c: @T}; fn unbox<@T>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox::<int>(bfoo) == foo); } type box<T> = {c: @T}; fn unbox<T>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox::<int>(bfoo) == foo); } type box<copy T> = {c: @T}; fn unbox<copy T>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; log "see what's in our box"; assert (unbox::<int>(bfoo) == foo); } type box<copy T> = {c: @T}; fn unbox<copy T>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; #debug("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } type box<T: copy> = {c: @T}; fn unbox<T: copy>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; #debug("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } type box<T: copy> = {c: @T}; fn unbox<T: copy>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; debug!{"see what's in our box"}; assert (unbox::<int>(bfoo) == foo); } type box<T: copy> = {c: @T}; fn unbox<T: copy>(b: box<T>) -> T { return *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; debug!{"see what's in our box"}; assert (unbox::<int>(bfoo) == foo); } type box<T: copy> = {c: @T}; fn unbox<T: copy>(b: box<T>) -> T { return *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } type box<T: Copy> = {c: @T}; fn unbox<T: Copy>(b: box<T>) -> T { return *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. type box<T: Copy> = {c: @T}; fn unbox<T: Copy>(b: box<T>) -> T { return *b.c; } fn main() { let foo: int = 17; let bfoo: box<int> = {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T: Copy> {c: @T} fn unbox<T: Copy>(b: Box<T>) -> T { return *b.c; } fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T: Copy>(b: Box<T>) -> T { return *b.c; } fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T: Copy>(b: Box<T>) -> T { return *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Copy>(b: Box<T>) -> T { return *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert (unbox::<int>(bfoo) == foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Copy>(b: Box<T>) -> T { return *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); fail_unless!((unbox::<int>(bfoo) == foo)); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Copy>(b: Box<T>) -> T { return *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert!((unbox::<int>(bfoo) == foo)); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Copy>(b: Box<T>) -> T { return *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Copy>(b: Box<T>) -> T { return copy *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Copy>(b: Box<T>) -> T { return copy *b.c; } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; info!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; info!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; info2!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. struct Box<T> {c: @T} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; info!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[feature(managed_boxes)]; struct Box<T> {c: @T} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; info!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #[feature(managed_boxes)]; struct Box<T> {c: @T} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; println!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(managed_boxes)] struct Box<T> {c: @T} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; println!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(managed_boxes)] use std::gc::{Gc, GC}; struct Box<T> {c: Gc<T>} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: box(GC) foo}; println!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use std::gc::{Gc, GC}; struct Box<T> {c: Gc<T>} fn unbox<T:Clone>(b: Box<T>) -> T { return (*b.c).clone(); } pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: box(GC) foo}; println!("see what's in our box"); assert_eq!(unbox::<int>(bfoo), foo); }