repr(transparent) does not allow a struct containing an array to be treated like an array

Question

I need a struct to be treated like an array of 16 unsigned integers, and that passing CreditCard type would be transparent as I would be passing an array of 16 unsigned integers.

How to make this code to work as it was designed to work?

use std::fmt;
/// Credit Card type
#[repr(transparent)]
pub struct CreditCard([u8; 16]);

impl fmt::Display for CreditCard {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{}{}{}{}-{}{}{}{}-{}{}{}{}-{}{}{}{}",
            self[0],
            self[1],
            self[2],
            self[3],
            self[4],
            self[5],
            self[6],
            self[7],
            self[8],
            self[9],
            self[10],
            self[11],
            self[12],
            self[13],
            self[14],
            self[15]
        )
    }
}
fn process_cc(card: CreditCard) {
    // do whatever
    println!("processed CC {}", card);
}
fn main() {
    let cc: CreditCard = [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4];
    println!("cc = {}", cc);
    let card_data: [u8; 16] = [1, 2, 3, 4, 2, 2, 2, 2, 9, 8, 7, 6, 5, 5, 5, 5];
    process_cc(card_data);
}

Playground

error[E0608]: cannot index into a value of type `&CreditCard`
  --> src/main.rs:11:13
   |
11 |             self[0],
   |             ^^^^^^^

...

error[E0308]: mismatched types
  --> src/main.rs:38:16
   |
38 |     process_cc(card_data);
   |                ^^^^^^^^^ expected struct `CreditCard`, found array of 16 elements
   |
   = note: expected type `CreditCard`
              found type `[u8; 16]`

Answer 1

That's not at all what repr(transparent) is intended for. Frankly, I'm baffled that you found such a niche feature and didn't read the documentation for it:

Structs with this representation have the same layout and ABI as the single non-zero sized field.

This has nothing to do with how the type behaves in the type system, only with how the memory of a value of the type is structured.

What you want to do doesn't even really belong in a strongly typed language. You can't just assign an array to another type because it's another type. With repr(transparent) it's valid to transmute the bits from one to another, but that will never happen automatically.

The better alternative is to implement Deref and From for your type:

use std::ops::Deref;

impl Deref for CreditCard {
    type Target = [u8; 16];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<[u8; 16]> for CreditCard {
    fn from(other: [u8; 16]) -> Self {
        CreditCard(other)
    }
}

Then take any type that can be turned into a CreditCard:

fn process_cc(card: impl Into<CreditCard>) {
    // do whatever
    println!("processed CC {}", card.into());
}

See also:

• Is it considered a bad practice to implement Deref for newtypes?
• When should I implement std::convert::From vs std::convert::Into?

---

If you were dead-set on using repr(transparent), you'd need to do something like:

fn process_cc(card: [u8; 16]) {
    use std::mem;
    let card: CreditCard = unsafe { mem::transmute(card) };
    // do whatever
    println!("processed CC {}", card);
}

This is generally a very bad idea and it's highly likely you should not do this.