جنریک‌ها

// یک تابع همانی ساده برای آرایه‌ای با اندازه ثابت
fn identity_pair<T>(values: T[2]) T[2] {
    return values;
}

pub fn main() {
    // استنتاج خودکار
    const p1 = identity_pair({1, 2});

    // آرگومان‌های نوع صریح
    const p2 = identity_pair<int>({3, 4});

    printf("%d %d\n", p1[0], p2[0]);
}

fn count_to_five<T>(x: T) {
    printf("%d ", x);

    if (x < 5) {
        count_to_five(x + 1);
    }
}

struct Pair<K, V> {
    pub key: K;
    pub value: V;
}

pub fn main() {
    // K به صورت صریح (uint)، اما اجازه دهید کامپایلر V را استنتاج کند
    const entry = Pair<uint, _> {
        key: 1,
        value: "Cyrus"
    };
}

enum Option<T> {
    Some(T),
    None
}

fn print_opt(opt: Option<int>) {
    switch (opt) {
        case .Some(val) => {
            printf("Value: %d\n", val);
        }
        case .None => {
            printf("Nothing\n");
        }
    }
}

struct Math {
    // یک متد جنریک در یک struct غیر جنریک
    pub fn add<T>(x: T, y: T) T {
        return x + y;
    }
}

struct Box<T> {
    value: T;

    // 'Self' به Box<T> اشاره دارد
    pub fn new(val: T) Self {
        return Self { value: val };
    }
}

struct Result<V, E = uint64> {
    pub value: V;
    pub error_code: E;
}

pub fn main() {
    // از uint64 پیش‌فرض برای E استفاده می‌کند
    var res = Result<char*, _> { value: "Success", error_code: 0 };
}

struct Pair<K, V> {
    key: K;
    value: V;
}

// نام مستعار غیر جنریک برای یک نمونه جنریک خاص
type IntPair = Pair<int, int>;

// یک نام مستعار جنریک
type Handler<T> = fn(T) void;

pub fn main() {
    const log: Handler<int> = fn(x: int) void {
        printf("%d", x);
    };
}

interface IValidator<T> {
    fn validate(&const self, value: T) bool;
}

struct AgeValidator : IValidator<int> {
    pub fn validate(&const self, val: int) bool {
        return val >= 18;
    }
}

interface Shape<T> {
    fn area(&const self) T;
}

struct Rectangle<T> : Shape<T> {
    width: T;
    height: T;

    pub fn area(&const self) T {
        return self->width * self->height;
    }
}

struct InfixCalc<T> {
    pub x: T;
    pub y: T;

    pub fn new(const x: T, const y: T) Self {
        return Self { x, y };
    }

    // متد جنریک درون یک struct جنریک
    pub fn add_to_x<V>(&self, const val: V) {
        self->x += @cast(T, val);
    }

    // متد استاتیک جنریک
    pub fn static_sum<K>(const a: T, const b: K) T {
        return a + @cast(T, b);
    }
}

pub fn main() {
    var calc = InfixCalc.new(5, 7);

    // ارائه آرگومان نوع فقط برای متد
    // اگر به نمونه آرگومان نوع اضافه کنید، منجر به خطای زمان کامپایل می‌شود
    calc.add_to_x<uint32>(1);
    calc.add_to_x<uint64>(2);

    printf("%d\n", calc.x);

    // برای فراخوانی‌های استاتیک، ممکن است نیاز به ارائه هر دو داشته باشید:
    // InfixCalc<int64> نوع را مشخص می‌کند
    // static_sum<uint> تخصصی‌سازی متد را مشخص می‌کند
    const result = InfixCalc<int64>.static_sum<uint>(10, 20);
    printf("%d\n", result);

    // همچنین می‌توانید اجازه دهید کامپایلر آن را استنتاج کند:
    const result = InfixCalc.static_sum(10, 20);
    printf("%d\n", result);
}