//! returns: 0 //! Slice take moves slices of 1-byte, 8-byte, and 112-byte elements without copying or dropping //! elements. /// Allocation failures. @language union AllocError: Copy { /// The allocator cannot provide storage. OutOfMemory, } /// A heap, which holds elements of any type. @language record Heap {} /// Allocate the backing storage of a static heap. @intrinsic constant fn new(size: u32) -> Heap; /// The allocator view of a heap. @language record Allocator {} /// Element of 112 bytes and alignment 8. It is not `Copy`, so take must not duplicate it. record Wide { /// Field 0. f0: u64, /// Field 1. f1: u64, /// Field 2. f2: u64, /// Field 3. f3: u64, /// Field 4. f4: u64, /// Field 5. f5: u64, /// Field 6. f6: u64, /// Field 7. f7: u64, /// Field 8. f8: u64, /// Field 9. f9: u64, /// Field 10. f10: u64, /// Field 11. f11: u64, /// Field 12. f12: u64, /// Field 13. f13: u64, } /// Build a `Wide` element whose fields all depend on `v`. fn wide(v: u64) -> Wide { return Wide { f0: v, f1: v + 1, f2: v + 2, f3: v + 3, f4: v + 4, f5: v + 5, f6: v + 6, f7: v + 7, f8: v + 8, f9: v + 9, f10: v + 10, f11: v + 11, f12: v + 12, f13: v + 13, }; } /// Check that `w` matches `wide(v)` in every field. fn isWide(w: &Wide, v: u64) -> bool { return w.f0 == v and w.f1 == v + 1 and w.f2 == v + 2 and w.f3 == v + 3 and w.f4 == v + 4 and w.f5 == v + 5 and w.f6 == v + 6 and w.f7 == v + 7 and w.f8 == v + 8 and w.f9 == v + 9 and w.f10 == v + 10 and w.f11 == v + 11 and w.f12 == v + 12 and w.f13 == v + 13; } /// Backing storage for the allocator. static BUF: Heap = new(4096); @default unsafe fn main() -> i32 { assert @sizeOf(Wide) == 112; // One-byte elements. static bytes: [u8; 3] = [1, 2, 3]; let mut b: *mut [u8] = &mut bytes[..] as *mut [u8]; let tb = b.take(); assert tb.len == 3; assert tb.cap == 3; assert tb[2] == 3; assert b.len == 0; // Eight-byte elements. static words: [u64; 2] = [40, 50]; let mut w: *mut [u64] = &mut words[..] as *mut [u64]; let tw = w.take(); assert tw.len == 2; assert tw[1] == 50; assert w.len == 0; // Large elements. let arena = &BUF; let mut ws: *mut [Wide] = &mut []; try! ws.append(wide(1), arena); try! ws.append(wide(2), arena); let tws = ws.take(); assert tws.len == 2; assert tws.cap >= 2; assert isWide(&tws[1], 2); assert ws.len == 0; assert ws.cap == 0; return 0; }