chore: remove Immediate from Immediate::{Word, Byte, Operand}

It's already clear that its an Immediate value
without the prefix.

src/instructions.rs

@@ -2,18 +2,18 @@ use core::fmt;
 
 use crate::register::{Register, SegmentRegister};
 
-pub type ImmediateByte = u8;
-pub type ImmediateWord = u16;
+pub type Byte = u8; // b
+pub type Word = u16; // w or v
 
 #[derive(Debug, Clone)]
 #[allow(dead_code)]
 /// Encodes either Byte- or Word-sized operands.
-pub enum ImmediateOperand {
-    Byte(ImmediateByte),
-    Word(ImmediateWord),
+pub enum Operand {
+    Byte(Byte),
+    Word(Word),
 }
 
-impl fmt::Display for ImmediateOperand {
+impl fmt::Display for Operand {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Self::Byte(byte) => write!(f, "{}", byte),
@@ -70,10 +70,10 @@ pub enum Mnemonic {
     // ADD
     ADD_FromReg(ModRmTarget, Register), // From Register into either Memory or Register
     ADD_ToReg(ModRmTarget, Register),   // From either Memory or Register into Reigster
-    ADD_Ib(ModRmTarget, ImmediateByte), // From Immediate into either Memory or Register
-    ADD_Iv(ModRmTarget, ImmediateWord), // From Immediate into either Memory or Register
-    ADD_ALIb(ImmediateByte),
-    ADD_AXIv(ImmediateWord),
+    ADD_Ib(ModRmTarget, Byte),          // From Immediate into either Memory or Register
+    ADD_Iv(ModRmTarget, Word),          // From Immediate into either Memory or Register
+    ADD_ALIb(Byte),
+    ADD_AXIv(Word),
     // PUSH
     PUSH_R(Register),
     PUSH_S(SegmentRegister),
@@ -84,31 +84,31 @@ pub enum Mnemonic {
     // OR
     OR_FromReg(ModRmTarget, Register),
     OR_ToReg(ModRmTarget, Register),
-    OR_Ib(ModRmTarget, ImmediateByte),
-    OR_Iv(ModRmTarget, ImmediateWord),
-    OR_ALIb(ImmediateByte),
-    OR_AXIv(ImmediateWord),
+    OR_Ib(ModRmTarget, Byte),
+    OR_Iv(ModRmTarget, Word),
+    OR_ALIb(Byte),
+    OR_AXIv(Word),
     // ADC
     ADC_FromReg(ModRmTarget, Register),
     ADC_ToReg(ModRmTarget, Register),
-    ADC_Ib(ModRmTarget, ImmediateByte),
-    ADC_Iv(ModRmTarget, ImmediateWord),
-    ADC_ALIb(ImmediateByte),
-    ADC_AXIv(ImmediateWord),
+    ADC_Ib(ModRmTarget, Byte),
+    ADC_Iv(ModRmTarget, Word),
+    ADC_ALIb(Byte),
+    ADC_AXIv(Word),
     // SBB
     SBB_FromReg(ModRmTarget, Register),
     SBB_ToReg(ModRmTarget, Register),
-    SBB_Ib(ModRmTarget, ImmediateByte),
-    SBB_Iv(ModRmTarget, ImmediateWord),
-    SBB_ALIb(ImmediateByte),
-    SBB_AXIv(ImmediateWord),
+    SBB_Ib(ModRmTarget, Byte),
+    SBB_Iv(ModRmTarget, Word),
+    SBB_ALIb(Byte),
+    SBB_AXIv(Word),
     // AND
     AND_FromReg(ModRmTarget, Register),
     AND_ToReg(ModRmTarget, Register),
-    AND_Ib(ModRmTarget, ImmediateByte),
-    AND_Iv(ModRmTarget, ImmediateWord),
-    AND_ALIb(ImmediateByte),
-    AND_AXIv(ImmediateWord),
+    AND_Ib(ModRmTarget, Byte),
+    AND_Iv(ModRmTarget, Word),
+    AND_ALIb(Byte),
+    AND_AXIv(Word),
     // Override
     OVERRIDE(SegmentRegister),
     // Decimal Adjustment
@@ -119,45 +119,45 @@ pub enum Mnemonic {
     // SUB
     SUB_FromReg(ModRmTarget, Register),
     SUB_ToReg(ModRmTarget, Register),
-    SUB_Ib(ModRmTarget, ImmediateByte),
-    SUB_Iv(ModRmTarget, ImmediateWord),
-    SUB_ALIb(ImmediateByte),
-    SUB_AXIv(ImmediateWord),
+    SUB_Ib(ModRmTarget, Byte),
+    SUB_Iv(ModRmTarget, Word),
+    SUB_ALIb(Byte),
+    SUB_AXIv(Word),
     // XOR
     XOR_FromReg(ModRmTarget, Register),
     XOR_ToReg(ModRmTarget, Register),
-    XOR_Ib(ModRmTarget, ImmediateByte),
-    XOR_Iv(ModRmTarget, ImmediateWord),
-    XOR_ALIb(ImmediateByte),
-    XOR_AXIv(ImmediateWord),
+    XOR_Ib(ModRmTarget, Byte),
+    XOR_Iv(ModRmTarget, Word),
+    XOR_ALIb(Byte),
+    XOR_AXIv(Word),
     // CMP
     CMP_FromReg(ModRmTarget, Register),
     CMP_ToReg(ModRmTarget, Register),
-    CMP_Ib(ModRmTarget, ImmediateByte),
-    CMP_Iv(ModRmTarget, ImmediateWord),
-    CMP_ALIb(ImmediateByte),
-    CMP_AXIv(ImmediateWord),
+    CMP_Ib(ModRmTarget, Byte),
+    CMP_Iv(ModRmTarget, Word),
+    CMP_ALIb(Byte),
+    CMP_AXIv(Word),
     // INC
     INC(Register),
     // DEC
     DEC(Register),
     // Jumps
-    JO(ImmediateByte),
-    JNO(ImmediateByte),
-    JB(ImmediateByte),
-    JNB(ImmediateByte),
-    JZ(ImmediateByte),
-    JNZ(ImmediateByte),
-    JBE(ImmediateByte),
-    JA(ImmediateByte),
-    JS(ImmediateByte),
-    JNS(ImmediateByte),
-    JPE(ImmediateByte),
-    JPO(ImmediateByte),
-    JL(ImmediateByte),
-    JGE(ImmediateByte),
-    JLE(ImmediateByte),
-    JG(ImmediateByte),
+    JO(Byte),
+    JNO(Byte),
+    JB(Byte),
+    JNB(Byte),
+    JZ(Byte),
+    JNZ(Byte),
+    JBE(Byte),
+    JA(Byte),
+    JS(Byte),
+    JNS(Byte),
+    JPE(Byte),
+    JPO(Byte),
+    JL(Byte),
+    JGE(Byte),
+    JLE(Byte),
+    JG(Byte),
     // TEST
     TEST(ModRmTarget, Register),
     //XHCG
@@ -168,7 +168,7 @@ pub enum Mnemonic {
     MOV_ToReg(ModRmTarget, Register),
     MOV_FromSReg(ModRmTarget, SegmentRegister),
     MOV_ToSReg(ModRmTarget, SegmentRegister),
-    MOV_BXIv(ImmediateWord),
+    MOV_BXIv(Word),
     // LEA
     LEA(ModRmTarget, Register),
     // Sign extensions
@@ -184,7 +184,7 @@ pub enum Mnemonic {
     SAHF,
     LAHF,
     // INT
-    INT(ImmediateByte),
+    INT(Byte),
 }
 
 impl fmt::Display for Mnemonic {
@@ -225,7 +225,7 @@ impl std::fmt::Display for ModRmTarget {
 pub struct MemoryIndex {
     pub base: Option<Register>,
     pub index: Option<Register>,
-    pub displacement: Option<ImmediateOperand>,
+    pub displacement: Option<Operand>,
 }
 
 impl fmt::Display for MemoryIndex {
@@ -255,8 +255,8 @@ impl fmt::Display for MemoryIndex {
 #[derive(Debug, Clone)]
 /// 32-bit segment:offset pointer (e.g. for CALL instruction)
 pub struct Pointer {
-    pub segment: ImmediateWord,
-    pub offset: ImmediateWord,
+    pub segment: Word,
+    pub offset: Word,
 }
 
 impl std::fmt::Display for Pointer {