I wonder it would be acceptable to implement these via `transmute`:

```rust
let vec: [u8, .. 2] = unsafe {cast::transmute(*self)};
stream.input(vec)
```

etc.

The transmute version optimises far better:

```rust
#[no_mangle]
pub fn trans(x: u16) -> [u8, .. 2] {
    unsafe { std::cast::transmute(x) }
}

#[no_mangle]
pub fn shift(x: u16) -> [u8, .. 2] {
    [(x >> 8) as u8, x as u8]
}
```

Compile to:
```llvm
; Function Attrs: nounwind uwtable
define void @trans([4 x i8]* noalias nocapture sret, i32) unnamed_addr #0 {
entry-block:
  %2 = bitcast [4 x i8]* %0 to i32*
  store i32 %1, i32* %2, align 4
  ret void
}

; Function Attrs: nounwind uwtable
define void @shift([4 x i8]* noalias nocapture sret, i32) unnamed_addr #0 {
entry-block:
  %2 = getelementptr inbounds [4 x i8]* %0, i64 0, i64 0
  %3 = trunc i32 %1 to i8
  store i8 %3, i8* %2, align 1
  %4 = getelementptr inbounds [4 x i8]* %0, i64 0, i64 1
  %5 = lshr i32 %1, 8
  %6 = trunc i32 %5 to i8
  store i8 %6, i8* %4, align 1
  %7 = getelementptr inbounds [4 x i8]* %0, i64 0, i64 2
  %8 = lshr i32 %1, 16
  %9 = trunc i32 %8 to i8
  store i8 %9, i8* %7, align 1
  %10 = getelementptr inbounds [4 x i8]* %0, i64 0, i64 3
  %11 = lshr i32 %1, 24
  %12 = trunc i32 %11 to i8
  store i8 %12, i8* %10, align 1
  ret void
}
```

(and the difference is even large for large types like `u64`.)

Of course, this then involves `unsafe {}`, as well as then being endianness-dependent.

I guess we could use use `transmute(std::unstable::intrinsics::to_le16(*self))`, so that it's super fast on the most common platforms, but still endianness-independent.

I guess it might be worth measuring, to see if it actually makes a difference.