Enums மற்றும் வகை மாற்றுப்பெயர்கள்

Wave C போன்ற ஒரு வெளிப்படையான வகை அமைப்பைப் பராமரிக்கிறது, வாசிப்புத்திறன் மற்றும் ABI நிலைத்தன்மைக்கு, மாற்றுப்பெயர்களைத் தட்டச்சு செய்யவும் முழு எண் அடிப்படையிலான கணக்கீட்டை ஆதரிக்கிறது.

---

மாற்றுப்பெயரை டைப் செய்யவும்

கண்ணோட்டம்

டைப் திறவுச்சொல் ஏற்கனவே உள்ள வகைக்கு புதிய பெயரைக் கொடுக்கும். இது ஒரு புதிய வகையை உருவாக்கவில்லை, ஆனால் இது ஒரு முழுமையான சமன்பாடு (மாறுபெயர்) ஆகும்.

type MyInt = i32;

மேலே உள்ள அறிவிப்பில், MyInt என்பது i32 போன்ற அதே வகையாகும்.

---

அம்சங்கள்

• மேல்நிலை இயக்க நேரம் இல்லை
• ABI சரியாகவே உள்ளது
• தொகுக்கும் நேரத்தில் மட்டுமே உள்ளது
• enum இன் பிரதிநிதி வகையாகப் பயன்படுத்தலாம்

---

எடுத்துக்காட்டு பயன்பாடு

type Size = i64;
type Index = u32;

fun add(a: Size, b: Size) -> Size {
    return a + b;
}

---

வகை சமன்பாடு

type A = i32;
type B = A;

fun f(x: i32) -> i32 { return x; }

fun main() {
    var v: B = 10;
    f(v); // OK
}

வகை என்பது புதிய வகை அல்ல, வேறு பெயர் கொண்ட வகை.

---

கணக்கீடு

கண்ணோட்டம்

Wave இன் enum என்பது முழு எண் அடிப்படையிலான கணக்கீட்டு வகையாகும். ஒவ்வொரு எண்ணும் வகை பிரதிநிதியைக் கொண்டிருக்க வேண்டும்.

enum ShaderUniformType -> i32 {
    A = 0,
    B,
    C = 10,
    D
}

---

பிரதிநிதி வகை

-> i32 என்பது இந்த enum எந்த முழு எண் வகையாக வெளிப்படுத்தப்படுகிறது என்பதைக் குறிக்கிறது.

ஏற்றுக்கொள்ளப்பட்ட பிரதிநிதி வகைகள்:

• i8, i16, i32, i64
• u8, u16, u32, u64
• தொடர்புடைய வகையின் type alias

type MyInt = i32;

enum Example -> MyInt {
    X,
    Y
}

---

மதிப்பு ஒதுக்கீட்டு விதிகள்

• வெளிப்படையான மதிப்பு இருந்தால், அந்த மதிப்பைப் பயன்படுத்தவும்
• இல்லையெனில், முந்தைய மதிப்பு + 1
• முதல் மதிப்பு இல்லை என்றால், 0 இலிருந்து தொடங்கவும்

enum E -> i32 {
    A,        // 0
    B,        // 1
    C = 10,   // 10
    D         // 11
}

---

enum ஒரு மதிப்பு வகை

enum என்பது ஒரு முழு எண் மதிப்பாகும், மேலும் இது ஒரு செயல்பாட்டு வாதம் அல்லது திரும்பும் மதிப்பாக சுதந்திரமாகப் பயன்படுத்தப்படலாம்.

fun f(t: ShaderUniformType) -> i32 {
    return t;
}

---

நிலையானதாக பயன்படுத்தப்படுகிறது

ஒரு enum மாறுபாடு என்பது தொகுக்கும் நேர மாறிலி ஆகும்.

const X: i32 = B;
const Y: ShaderUniformType = D;

---

உண்மையான உதாரணம்

type MyInt = i32;

enum ShaderUniformType -> MyInt {
    A = 0,
    B,
    C = 10,
    D
}

const X: MyInt = 123;
const Y: MyInt = B;
const Z: ShaderUniformType = D;

fun f(t: ShaderUniformType) -> MyInt {
    return t;
}

fun g(v: MyInt) -> MyInt {
    return v;
}

fun main() {
    println("{}", f(A)); // 0
    println("{}", f(B)); // 1
    println("{}", f(C)); // 10
    println("{}", f(D)); // 11

    println("{}", g(X)); // 123
    println("{}", g(Y)); // 1
    println("{}", f(Z)); // 11
}