Odin Programming Language

package main

import "core:fmt"

main :: proc() {
	greetings := []string{"Hellope", "Bonjour", "こんにちは"}
	for greeting, i in greetings {
		fmt.println(i, "=", greeting)
	}
}

package main

import "core:fmt"

main :: proc() {
	a := [3]f32{1, 2, 3}
	b := [3]f32{4, 5, 6}

	fmt.println(a * b) // [4, 10, 18]  component-wise
	fmt.println(a + b) // [5, 7, 9]
	fmt.println(a.zyx) // [3, 2, 1]    swizzle
}

package main

import "core:fmt"

main :: proc() {
	nums := make([]int, 3)
	defer delete(nums) // runs when main returns

	nums[0], nums[1], nums[2] = 1, 2, 3
	fmt.println(nums)
}

package main

import "core:fmt"

Permission  :: enum {Read, Write, Execute}
Permissions :: bit_set[Permission]

main :: proc() {
	p: Permissions = {.Read, .Write}
	fmt.println(.Execute in p)  // false
	fmt.println(p + {.Execute}) // Permissions{Read, Write, Execute}
}

package main

import "core:fmt"

Suit :: enum {Hearts, Diamonds, Clubs, Spades}

main :: proc() {
	symbols := [Suit]rune{
		.Hearts   = '♥',
		.Diamonds = '♦',
		.Clubs    = '♣',
		.Spades   = '♠',
	}
	fmt.println(symbols[.Spades]) // ♠
}

package main

import "core:fmt"

Pos :: struct { line, col: int }

Token :: struct {
	using pos: Pos,
	text: string,
}

main :: proc() {
	tok := Token{Pos{3, 12}, "hello"}
	fmt.println(tok.line, tok.col) // reach in without .pos
	fmt.println(tok.text)
}

package main

import "core:fmt"

main :: proc() {
	xs := [5]int{10, 20, 30, 40, 50}

	fmt.println(xs[:])   // [10, 20, 30, 40, 50]  whole array as a view
	fmt.println(xs[1:4]) // [20, 30, 40]
	fmt.println(xs[2:])  // [30, 40, 50]
	fmt.println(xs[:3])  // [10, 20, 30]
}

package main

import "core:fmt"

main :: proc() {
	grid := [3][3]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
	}

	search: for row, y in grid {
		for val, x in row {
			if val == 5 {
				fmt.printfln("found at (%d, %d)", x, y)
				break search
			}
		}
	}
}

package main

import "core:fmt"

divmod :: proc(a, b: int) -> (quotient, remainder: int) {
	return a / b, a % b
}

main :: proc() {
	q, r := divmod(17, 5)
	fmt.println(q, r) // 3 2
}

package main

import "core:simd"

// Vectorized check that a utf8 buffer is all ASCII
is_ascii :: proc(utf8: []#simd[16]u8) -> bool {
	acc: #simd[16]u8
	for chunk in utf8 {
		acc |= chunk // fold every set of code units into the result
	}
	return simd.reduce_max(acc) < 0x80 // every lane in the ASCII range?
}

package main

import "core:fmt"

rdtsc :: asm() -> (lo, hi: u32) [
	lo = %eax,
	hi = %edx,
] {
	rdtsc
}

main :: proc() {
	lo, hi := rdtsc()
	cycles := (u64(hi) << 32) | u64(lo)
	fmt.println("cycle counter:", cycles)
}