Implementation of the ideal memory layout in rust - memory

Question

I'm new to Rust and tried to "translate" a chess engine I made in Python into Rust. Since Rust is a more low-level programming language than Python, I care about the memory layout of my program, but don't know how to write my code to store the chess board as efficient as possible in memory
My first approach was a struct with a 2-dimensional array (8x8) to represent the chess board. The items are structs Piece, which contaions information about the piece-type (enum) and the color (enum). My code for this is:
#[derive(Debug, Copy, Clone)]
pub enum PieceTypes{
Pawn,
Knight,
Bishop,
Rook,
Queen,
King,
}
#[derive(Debug, Copy, Clone)]
pub enum Colors{
White,
Black,
}
#[derive(Debug, Copy, Clone)]
pub struct Piece{
pub piece_typ: PieceTypes,
pub color:Colors,
}
pub struct Board{
pub squares:[[Option<Piece>; 8]; 8],
}
But the size of an initialized Board-Struct in memory is 128 bytes. 16 bytes per row, 2 bytes per square.This is, of course, perfetly fine, but 8 different pieces with 2 different colors (16 possibilities) definitely don't require 2 bytes (65536 possibilities). Probably this is because the piece type and the color are stored in seperate bytes.
As the beginner I am I wonder how to layout my code so one square uses one byte in memory (Also: Because I am, as mentioned, quite a noob in Rust, explicit code examples would be really helpful)

Answer 1

You can use my library superbitty instead of manual bitfields:
#[derive(Debug, Copy, Clone, superbitty::BitFieldCompatible)]
pub enum PieceTypes {
None,
Pawn,
Knight,
Bishop,
Rook,
Queen,
King,
}
#[derive(Debug, Copy, Clone, superbitty::BitFieldCompatible)]
pub enum Colors {
White,
Black,
}
superbitty::bitfields! {
#[derive(Debug, Copy, Clone)]
pub struct Piece : u8 {
pub piece_typ: PieceTypes,
pub color: Colors,
}
}
#[derive(Debug)]
pub struct Board {
pub squares: [[Piece; 8]; 8],
}
fn main() {
assert_eq!(std::mem::size_of::<Board>(), 64);
let mut board = Board { squares: [[Piece::new(PieceTypes::None, Colors::White); 8]; 8] };
board.squares[0][0].set_piece_typ(PieceTypes::Queen);
board.squares[0][1] = Piece::new(PieceTypes::King, Colors::Black);
dbg!(board.squares[0][1].piece_typ(), board.squares[0][1].color());
dbg!(board);
}
However, I'd recommend you to not bother, unless you benchmarked and can prove a performance gain. This can actually hurt your performance.