State :: enum {
	idle
	ready
	failed
}

Point :: struct {
	x i32
	y i32
}

Box :: union(enum) {
	point Point
	empty void
}

Error :: enum {
	bad
}

make_point func() Point {
	return Point { x = 3, y = 4 }
}

sum_loop func(limit i32) i32 {
	total i32 = 0
	i i32 = 0
	while i < limit {
		i += 1
		if i == 2 {
			continue
		}
		total += i
	}
	return total
}

sum_for func() i32 {
	total i32 = 0
	values [_]i32 = [1, 2, 3]
	for values |value, index| {
		total += value + index
	}
	return total
}

defer_value func() i32 {
	value i32 = 1
	{
		defer value += 10
		value += 1
	}
	return value
}

describe func(box Box) i32 {
	return match box {
		.point |p|: p.x + p.y
		.empty: 0
	}
}

maybe func(flag bool) ?i32 {
	if flag {
		return 9
	}
	return none
}

may_fail func(flag bool) i32 ! Error {
	if flag {
		return .bad
	}
	return 7
}

use_try func() i32 ! Error {
	value :: try may_fail(false)
	return value + 1
}

recover func() i32 {
	return may_fail(true) catch |e| {
		match e {
			.bad: yield 5
		}
	}
}

GLOBAL :: $sum_loop(4)

main func() i32 {
	point Point :: $make_point()
	numbers [_]i32 :: $[4, 5, 6]
	box Box :: $Box { point = Point { x = 8, y = 1 } }
	state State :: $State.ready
	name :: $"bro"
	value i32 :: $sum_for()
	deferred i32 :: $defer_value()
	optional i32 :: $maybe(true)?
	tried i32 :: $use_try() catch 0
	recovered i32 :: $recover()

	if point.x + point.y != 7 {
		return 1
	}
	if numbers.len != 3 or numbers[2] != 6 {
		return 2
	}
	if describe(box) != 9 {
		return 3
	}
	if state != State.ready {
		return 4
	}
	if name.len != 3 {
		return 5
	}
	if value != 9 {
		return 6
	}
	if deferred != 12 {
		return 7
	}
	if optional != 9 {
		return 8
	}
	if tried != 8 {
		return 9
	}
	if recovered != 5 {
		return 10
	}
	if GLOBAL != 8 {
		return 11
	}
	return 0
}