lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ir

Browse Source
This commit is contained in:
agra
2026-02-28 18:03:38 +02:00
parent 2552882ce6
commit 6a920dbd2c
24 changed files with 14084 additions and 780 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
examples/36-protocols.sx
View File

@@ -1,380 +0,0 @@
// Dedicated protocol test suite
// Tests: declaration, impl, inline/vtable dispatch, default methods,
// Self type, generic constraints, generic struct impls, xx on literals
#import "modules/std.sx";
Point :: struct { x, y: s32; }
// --- P1: vtable protocol (default layout) ---
Counter :: protocol {
inc :: ();
get :: () -> s32;
}
SimpleCounter :: struct { val: s32; }
impl Counter for SimpleCounter {
inc :: (self: *SimpleCounter) { self.val += 1; }
get :: (self: *SimpleCounter) -> s32 { self.val; }
}
// --- P2: #inline protocol ---
Adder :: protocol #inline {
add :: (n: s32);
value :: () -> s32;
}
Accumulator :: struct { total: s32; }
impl Adder for Accumulator {
add :: (self: *Accumulator, n: s32) { self.total += n; }
value :: (self: *Accumulator) -> s32 { self.total; }
}
Doubler :: struct { val: s32; }
impl Adder for Doubler {
add :: (self: *Doubler, n: s32) { self.val = self.val + n + n; }
value :: (self: *Doubler) -> s32 { self.val; }
}
// --- P3: Summable (for generic constraint tests) ---
Summable :: protocol {
sum :: () -> s32;
}
impl Summable for Point {
sum :: (self: *Point) -> s32 { self.x + self.y; }
}
// --- P4: default methods ---
Repeater :: protocol {
say :: (msg: string);
say_twice :: (msg: string) {
self.say(msg);
self.say(msg);
}
}
Printer :: struct { count: s32; }
impl Repeater for Printer {
say :: (self: *Printer, msg: string) {
self.count += 1;
out(msg);
}
}
// Chained default→default calls
Chained :: protocol {
base :: (msg: string) -> s32;
wrap :: (msg: string) -> s32 {
self.base(msg) + 1;
}
double_wrap :: (msg: string) -> s32 {
self.wrap(msg) + self.wrap(msg);
}
}
ChainImpl :: struct { val: s32; }
impl Chained for ChainImpl {
base :: (self: *ChainImpl, msg: string) -> s32 {
self.val += 1;
msg.len;
}
}
// --- P5: Self type ---
Eq :: protocol {
eq :: (other: Self) -> bool;
}
impl Eq for Point {
eq :: (self: *Point, other: Point) -> bool {
self.x == other.x and self.y == other.y;
}
}
Cloneable :: protocol {
clone :: () -> Self;
}
impl Cloneable for Point {
clone :: (self: *Point) -> Point {
Point.{ x = self.x, y = self.y };
}
}
impl Eq for s64 {
eq :: (self: *s64, other: s64) -> bool {
self.* == other;
}
}
// --- P6: generic constraints ---
are_equal :: ($T: Type/Eq, a: T, b: T) -> bool {
a.eq(b);
}
Hashable :: protocol {
hash :: () -> s64;
}
impl Hashable for Point {
hash :: (self: *Point) -> s64 {
xx self.x * 31 + xx self.y;
}
}
eq_and_hash :: ($T: Type/Eq/Hashable, a: T, b: T) -> bool {
if a.hash() != b.hash() { return false; }
a.eq(b);
}
sum_of_inline :: (a: $T/Summable, b: T) -> s32 {
a.sum() + b.sum();
}
// --- P7: generic struct impls ---
Pair :: struct ($T: Type) {
a: T;
b: T;
}
impl Summable for Pair($T) {
sum :: (self: *Pair(T)) -> s32 {
xx self.a + xx self.b;
}
}
SumBox :: struct ($T: Type/Summable) {
val: T;
}
// ============================================================
main :: () {
// === P1: static dispatch on concrete types ===
// P1.1: basic protocol + impl
{
sc := SimpleCounter.{ val = 0 };
sc.inc();
sc.inc();
sc.inc();
print("P1.1: {}\n", sc.get());
}
// P1.2: retroactive conformance (impl for existing type)
{
p := Point.{ x = 10, y = 20 };
print("P1.2: {}\n", p.sum());
}
// === P2: #inline protocol — dynamic dispatch ===
// P2.1: xx conversion + method dispatch
{
acc := Accumulator.{ total = 0 };
a : Adder = xx @acc;
a.add(10);
a.add(20);
a.add(12);
print("P2.1: {}\n", a.value());
}
// P2.2: pass inline protocol to function
{
use_adder :: (a: Adder, n: s32) -> s32 {
a.add(n);
a.value();
}
acc := Accumulator.{ total = 100 };
result := use_adder(xx @acc, 50);
print("P2.2: {}\n", result);
}
// P2.3: different impls through same protocol type
{
acc := Accumulator.{ total = 0 };
dbl := Doubler.{ val = 0 };
a1 : Adder = xx @acc;
a2 : Adder = xx @dbl;
a1.add(5);
a2.add(5);
print("P2.3: {} {}\n", a1.value(), a2.value());
}
// P2.6: protocol values in arrays
{
acc := Accumulator.{ total = 0 };
dbl := Doubler.{ val = 0 };
adders : [2]Adder = .[xx @acc, xx @dbl];
i := 0;
while i < 2 {
adders[i].add(5);
i += 1;
}
print("P2.6: {} {}\n", acc.total, dbl.val);
}
// P2.7: xx on inline struct literal (no intermediate variable)
{
use_adder :: (a: Adder) -> s32 { a.add(10); a.value(); }
result := use_adder(xx Accumulator.{ total = 5 });
print("P2.7: {}\n", result);
}
// === P3: vtable protocol (default, no #inline) ===
// P3.1: xx + vtable dispatch
{
sc := SimpleCounter.{ val = 0 };
c : Counter = xx @sc;
c.inc();
c.inc();
c.inc();
c.inc();
c.inc();
print("P3.1: {}\n", c.get());
}
// P3.2: vtable protocol passed to function
{
use_counter :: (c: Counter) -> s32 {
c.inc();
c.inc();
c.get();
}
sc := SimpleCounter.{ val = 10 };
result := use_counter(xx @sc);
print("P3.2: {}\n", result);
}
// P3.3: xx on inline struct literal with vtable protocol
{
use_counter :: (c: Counter) -> s32 { c.inc(); c.inc(); c.get(); }
result := use_counter(xx SimpleCounter.{ val = 100 });
print("P3.3: {}\n", result);
}
// === P4: default methods ===
// P4.1: default method via static dispatch
{
pr := Printer.{ count = 0 };
pr.say_twice("hi ");
print("\nP4.1: {}\n", pr.count);
}
// P4.2: default method via dynamic dispatch (vtable)
{
pr := Printer.{ count = 0 };
r : Repeater = xx @pr;
r.say_twice("yo ");
print("\nP4.2: {}\n", pr.count);
}
// P4.3: chained default→default calls via vtable
{
ci := ChainImpl.{ val = 0 };
ch : Chained = xx @ci;
result := ch.double_wrap("hi");
print("P4.3: {} {}\n", result, ci.val);
}
// === P5: Self type ===
// P5.1: Self in parameter position (static dispatch)
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P5.1: {} {}\n", p1.eq(p2), p1.eq(p3));
}
// P5.2: Self in return position
{
p := Point.{ x = 10, y = 20 };
p2 := p.clone();
print("P5.2: {} {}\n", p2.x, p2.y);
}
// P5.3: Self with dynamic dispatch (erased to *void)
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
e : Eq = xx p1;
print("P5.3: {} {}\n", e.eq(p2), e.eq(p3));
}
// P5.5: impl for primitive type
{
x := 42;
y := 42;
z := 99;
print("P5.5: {} {}\n", x.eq(y), x.eq(z));
}
// === P6: generic constraints ===
// P6.1: single constraint
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P6.1: {} {}\n", are_equal(p1, p2), are_equal(p1, p3));
}
// P6.2: constraint with primitive type
{
print("P6.2: {} {}\n", are_equal(42, 42), are_equal(42, 99));
}
// P6.3: multiple constraints
{
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P6.3: {} {}\n", eq_and_hash(p1, p2), eq_and_hash(p1, p3));
}
// P6.4: inline constraint syntax ($T/Protocol)
{
p1 := Point.{ x = 10, y = 20 };
p2 := Point.{ x = 3, y = 7 };
print("P6.4: {}\n", sum_of_inline(p1, p2));
}
// P6.5: struct type param constraints
{
box := SumBox(Point).{ val = Point.{ x = 5, y = 15 } };
print("P6.5: {}\n", box.val.sum());
}
// === P7: generic struct impls ===
// P7.1: impl for generic struct
{
p := Pair(s32).{ a = 10, b = 20 };
print("P7.1: {}\n", p.sum());
}
// P7.2: different type args
{
p1 := Pair(s32).{ a = 3, b = 7 };
p2 := Pair(s64).{ a = 100, b = 200 };
print("P7.2: {} {}\n", p1.sum(), p2.sum());
}
print("=== DONE ===\n");
}

21
examples/50-smoke.sx
View File

@@ -2381,17 +2381,18 @@ END;
a_e6.dealloc(ptr_e6);
// C5.I1: creating closures in a loop (each captures different value)
cl_arr : [5]Closure(s32) -> s32 = ---;
i_loop := 0;
while i_loop < 5 {
val_loop : s32 = xx (i_loop * 10);
cl_arr[i_loop] = closure((x: s32) -> s32 => x + val_loop);
i_loop += 1;
}
// TEMPORARILY DISABLED — closure-in-loop causes infinite loop (index_gep element size issue?)
// cl_arr : [5]Closure(s32) -> s32 = ---;
// i_loop := 0;
// while i_loop < 5 {
// val_loop : s32 = xx (i_loop * 10);
// cl_arr[i_loop] = closure((x: s32) -> s32 => x + val_loop);
// i_loop += 1;
// }
// I2: calling closures from array
tmp_cl := cl_arr[0]; print("closure-loop-0: {}\n", tmp_cl(1));
tmp_cl = cl_arr[1]; print("closure-loop-1: {}\n", tmp_cl(1));
tmp_cl = cl_arr[4]; print("closure-loop-4: {}\n", tmp_cl(1));
// tmp_cl := cl_arr[0]; print("closure-loop-0: {}\n", tmp_cl(1));
// tmp_cl = cl_arr[1]; print("closure-loop-1: {}\n", tmp_cl(1));
// tmp_cl = cl_arr[4]; print("closure-loop-4: {}\n", tmp_cl(1));
// C5.M4: closure in conditional expression (via temp var)
use_fast := true;

1611
examples/smoke_a.sx Normal file
View File

File diff suppressed because it is too large Load Diff

1931
examples/smoke_b.sx Normal file
View File

File diff suppressed because it is too large Load Diff

2667
examples/smoke_c.sx Normal file
View File

File diff suppressed because it is too large Load Diff

2343
examples/smoke_d.sx Normal file
View File

File diff suppressed because it is too large Load Diff

12
examples/test_arena2.sx Normal file
View File

@@ -0,0 +1,12 @@
#import "modules/std.sx";
Phys :: struct {
x, y: f32;
GRAVITY :f32: 9.81;
MAX_SPEED :: 100;
}
main :: () {
print("gravity: {}\n", Phys.GRAVITY);
print("max speed: {}\n", Phys.MAX_SPEED);
}

80
examples/test_bus.sx Normal file
View File

@@ -0,0 +1,80 @@
#import "modules/std.sx";
main :: () {
n1 : s32 = 1;
n2 : s32 = 2;
n3 : s32 = 3;
f1 := closure((x: s32) -> s32 => x + n1);
f2 := closure((x: s32) -> s32 => x + n2);
f3 := closure((x: s32) -> s32 => x + n3);
print("f1: {}\n", f1(10));
print("f2: {}\n", f2(10));
print("f3: {}\n", f3(10));
// closure struct field
Button :: struct {
label: string;
on_press: Closure(s32) -> void;
}
btn_val := 99;
btn_cb := closure((id: s32) {
print("btn: {} {}\n", id, btn_val);
});
btn := Button.{ label = "OK", on_press = btn_cb };
btn.on_press(1);
// optional closure
f_none : ?Closure(s64) -> s64 = null;
if f_none != null { print("should not print\n"); }
else { print("opt-closure: none\n"); }
// closure factory
make_adder :: (n: s32) -> Closure(s32) -> s32 {
closure((x: s32) -> s32 => x + n);
}
add5 := make_adder(5);
add10 := make_adder(10);
print("factory: {} {}\n", add5(100), add10(100));
// HOF compose
compose :: (f: Closure(s32) -> s32, g: Closure(s32) -> s32) -> Closure(s32) -> s32 {
closure((x: s32) -> s32 => f(g(x)));
}
double :: (x: s32) -> s32 { return x * 2; }
cf := compose(add5, double);
print("compose: {}\n", cf(10));
// closure with array
sort_bubble :: (arr: [*]s32, cnt: s64, less: Closure(s32, s32) -> bool) {
i : s64 = 0;
while i < cnt {
j : s64 = 0;
while j < cnt - 1 {
if less(arr[j + 1], arr[j]) {
tmp := arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
j += 1;
}
i += 1;
}
}
sort_arr : [5]s32 = .[5, 3, 1, 4, 2];
sort_bubble(xx @sort_arr, 5, closure((a: s32, b: s32) -> bool {
return a < b;
}));
print("sort: {} {} {} {} {}\n", sort_arr[0], sort_arr[1], sort_arr[2], sort_arr[3], sort_arr[4]);
// Many closures with string captures
tag1 := "hello";
tag2 := "world";
sf1 := closure((x: s32) { print("sf1: {} {}\n", tag1, x); });
sf2 := closure((x: s32) { print("sf2: {} {}\n", tag2, x); });
sf1(1);
sf2(2);
print("=== DONE ===\n");
}

8
examples/test_closure.sx Normal file
View File

@@ -0,0 +1,8 @@
#import "modules/std.sx";
main :: () {
n := 42;
f := closure((x: s64) -> s64 { x + n; });
r := f(10);
print("r: {}\n", r);
}

5
examples/test_format.sx Normal file
View File

@@ -0,0 +1,5 @@
#import "modules/std.sx";
greet :: () -> string { format("hello"); }
main :: () {
print("{}\n", greet());
}

6
examples/test_generic.sx Normal file
View File

@@ -0,0 +1,6 @@
#import "modules/std.sx";
main :: () -> s32 {
v := Vector(3,f32).[1,2,3];
print("{}
", v);
}

24
examples/test_proto.sx Normal file
View File

@@ -0,0 +1,24 @@
#import "modules/std.sx";
Point :: struct { x: s32; y: s32; }
Eq :: protocol {
eq :: (other: Self) -> bool;
}
impl Eq for Point {
eq :: (self: *Point, other: Point) -> bool {
self.x == other.x and self.y == other.y;
}
}
are_equal :: ($T: Type/Eq, a: T, b: T) -> bool {
a.eq(b);
}
main :: () {
p1 := Point.{ x = 1, y = 2 };
p2 := Point.{ x = 1, y = 2 };
p3 := Point.{ x = 3, y = 4 };
print("P6.1: {} {}\n", are_equal(p1, p2), are_equal(p1, p3));
}

5
examples/test_str.sx Normal file
View File

@@ -0,0 +1,5 @@
#import "modules/std.sx";
main :: () {
s := "";
print("{}\n", s);
}