چندریختی

// shape_types.cyrus
import std::libc{printf};

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

// Structها با استفاده از دو نقطه `:` پایبندی به رابط را اعلام می‌کنند
pub struct Square : Shape<float64> {
    side: float64;

    pub fn new(const side: float64) Self {
        return Self { side };
    }

    pub fn area(&const self) float64 {
        return self->side * self->side;
    }
}

// توزیع ایستا: کاملاً در زمان کامپایل وضوح می‌یابد
pub fn compute_area<T: Shape<float64>>(shape: T) -> float64 {
    return shape.area();
}

// توزیع پویا: در زمان اجرا از طریق یک اشاره‌گر چاق وضوح می‌یابد
pub fn print_area(shape: Shape<float64>) {
    // پرش غیرمستقیم از طریق جدول مجازی محلی شیء
    printf("%f\n", shape.area());
}

struct InterfaceObject {
    const data_ptr: void*;      // اشاره‌گر خام به حافظه نمونه (هپ/پشته)
    const vtable_ptr: void*;    // اشاره‌گر به vtable تولیدشده در محل ایجاد
}

شیء رابط (اشاره‌گر چاق)
┌───────────────────────────┐
│ data_ptr                  ├──────► [ داده‌های نمونه Square (side: 10.3) ]
├───────────────────────────┤
│ vtable_ptr                ├──────► [ Vtable تک‌شکلی‌شده ]
└───────────────────────────┘

import std::libc{printf};
import shape_types{Shape, Square};

pub fn main() {
    // بافت ۱: مقداردهی متغیر محلی
    const shape: Shape<float64> = dynamic Square.new(10.3);

    // بهینه‌سازی شده: تحلیلگر معنایی می‌داند 'shape' به‌طور قطعی یک 'Square' است
    printf("%f\n", shape.area());

    // بافت ۲: مرزهای حوزه (از دست دادن دانش نوع محلی)
    const shapes = Shape<float64>[2] {
        dynamic Square.new(10.3),
        shape
    };

    // بهینه‌سازی نشده: تغییرپذیری اندیس آرایه ارزیابی ایستا را غیرممکن می‌کند
    // کامپایلر خروجی می‌دهد: فراخوانی غیرمستقیم از طریق vtable_ptr
    for (var i = 0; i < 2; i++) {
        printf("%f\n", shapes[i].area());
    }
}

import std::libc{printf};

interface MyConstraint {
    fn foo(&self, x: int) int;
    fn bar(&self) char*;
}

struct Object : MyConstraint {
    name: char*;

    pub fn new(name: char*) Self {
        return Self { name };
    }
    pub fn foo(&self, x: int) int {
        return (x * 10) + 2;
    }
    pub fn bar(&self) char* {
        return self->name;
    }
}

enum Choice : MyConstraint {
    A,
    B,

    pub fn foo(&self, x: int) int {
        return -x;
    }
    pub fn bar(&self) char* {
        return "Choice";
    }
}

// تک‌شکلی در محل فراخوانی: کاملاً به پرش‌های ایستای تخصصی‌شده پاک‌سازی می‌شود
fn constraint_bar<T: MyConstraint>(object: T) {
    printf("%s %d | ", object.bar(), object.foo(3));
}

// توزیع پویای محل ایجاد: یک چیدمان اشاره‌گر چاق یکنواخت دریافت می‌کند
fn dynamic_interface(object: MyConstraint) {
    printf("%s %d | ", object.bar(), object.foo(5));
}

pub fn main() {
    const object1 = Object.new("Cyrus");
    const object2 = Choice.B;

    // ۱. چندریختی ایستا
    constraint_bar(object1);
    constraint_bar(object2);

    // ۲. چندریختی پویا
    const dynamic1: MyConstraint = dynamic object1;
    dynamic_interface(dynamic1);
    dynamic_interface(dynamic object1);
}

import std::libc{printf};

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

struct NumberValidator: IValidator<int> {
	pub fn validate(&const self, value: int) bool {
		if (value > 5) {
			return true;
		} else {
			return false;
		}
	}
}

pub fn main() {
	const validator: IValidator<int> = dynamic NumberValidator{};

	if (validator.validate(10)) {
		printf("yes\n");
	} else {
		printf("no\n");
	}
}

import std::libc{printf, malloc, free};

interface Allocator {
    fn alloc(&self, size: usize) void*;
    fn free(&self, ptr: void*) void;
}

struct HeapAllocator : Allocator {
    pub fn new() Self {
        return Self {};
    }

    pub fn alloc(&const self, size: usize) void* {
        return malloc(size);
    }

    pub fn free(&const self, ptr: void*) void {
        free(ptr);
    }
}

pub fn main() {
    const allocator = HeapAllocator.new();

    var ptr: int* = allocator.alloc(4);

    *ptr = 5;
    printf("%d\n", *ptr);

    allocator.free(ptr);
}