A program in my language showing function overloads: ``` struct Vec2 { x: u32, y: u32 } struct Vec3 { x: u32, y: u32, z: u32 } fn add(a: Vec2, b: Vec2): Vec2 { return Vec2 { a.x + b.x, a.y + b.y } } fn add(a: Vec3, b: Vec3): Vec3 { return Vec3 { a.x + b.x, a.y + b.y, a.z + b.z } } fn main(): u32 { let v2a = Vec2 { 3, 2 } let v2b = Vec2 { 4, 3 } let v2c = add(v2a, v2b) println(v2c) let v3a = Vec3 { 3, 2, 1 } let v3b = Vec3 { 2, 1, 1 } let v3c: Vec3 = add(v3a, v3b) println(v3c) return 0 } ```
The output of the program: ``` { 7, 5 } { 5, 3, 2 } ```
Had to implement some name mangling when emitting functions to lay the groundwork for interfaces, and I noticed this gave me function overloads for free. Take that, C!
#compiler #programming
![A program in my programming language showing string slicing:
```
fn main() {
var s: string = "Hello from osmium!";
println(s);
println(s[6..=10]);
var sl = s[8..17];
println(sl);
for c in s[0..5] {
print(c);
print(' ');
}
}
```](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:go6dmv3q3n2oicjdl27rkeuz/bafkreicz6sa6fya2f65dgcwmrbm4d45kewzdl74fqpqwv6fknszunrny3m)
![A program in my programming language showing array slicing:
```
fn print_slice(sl: []u32) {
for i in sl print(i);
}
fn main() {
var a = [*]u32 { 4, 5, 6, 7 };
print_slice(&a);
var sl: []u32 = a[2..=3];
print_slice(sl);
print(sl); //prints the raw underlying struct { ptr, len }
sl[0] = 1; //mutate the original array through the slice, makes sense since []T == &[N]T
for x in a print(x);
}
```](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:go6dmv3q3n2oicjdl27rkeuz/bafkreidponc4cfbwjgytot4qawdd5w76527c7nv3s5yvsentyru6mcoqby)
![The output of running the program:
```
4
5
6
7
6
7
{ &[0x61dff2e8], 2 }
4
5
1
7
```](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:go6dmv3q3n2oicjdl27rkeuz/bafkreiawnczhrrocr3axnutsxd2slntrxvolsekwxdniaaqrni5olceo2i)
