ఎనమ్స్ మరియు టైప్ మారుపేర్లు

Wave C మాదిరిగానే స్పష్టమైన రకం వ్యవస్థను నిర్వహిస్తుంది, రీడబిలిటీ మరియు ABI స్థిరత్వం కోసం, మారుపేర్లు మరియు టైప్ చేయండి పూర్ణాంక-ఆధారిత గణనకు మద్దతు ఇస్తుంది.

---

మారుపేరును టైప్ చేయండి

అవలోకనం

టైప్ కీవర్డ్ ఇప్పటికే ఉన్న రకానికి కొత్త పేరుని ఇస్తుంది. ఇది కొత్త రకాన్ని సృష్టించదు, కానీ పూర్తి సమానత్వం (అలియాస్).

type MyInt = i32;

పై డిక్లరేషన్‌లో, MyInt అనేది i32 వలె ఖచ్చితమైన రకం.

---

ఫీచర్లు

• రన్‌టైమ్ ఓవర్‌హెడ్ లేదు
• ABI సరిగ్గా అదే
• కంపైల్ సమయంలో మాత్రమే ఉంటుంది
• enum యొక్క repr రకంగా ఉపయోగించవచ్చు

---

ఉదాహరణ వినియోగం

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
}

---

repr రకం

-> 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
}