vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

odin.in (59878B)


      1 // vim: set ft=odin sw=4 ts=8 et:
      2 
      3 // START_INDENT
      4 
      5 #+vet !using-stmt !using-param
      6 #+feature dynamic-literals using-stmt
      7 package main
      8 
      9 import "core:fmt"
     10 import "core:mem"
     11 import "core:os"
     12 import "core:thread"
     13 import "core:time"
     14 import "core:reflect"
     15 import "base:runtime"
     16 import "base:intrinsics"
     17 import "core:math/big"
     18 import "core:math/rand"
     19 
     20 /*
     21 Odin is a general-purpose programming language with distinct typing built
     22 for high performance, modern systems and data-oriented programming.
     23 
     24 Odin is the C alternative for the Joy of Programming.
     25 
     26 # Installing Odin
     27 Getting Started - https://odin-lang.org/docs/install/
     28 Instructions for downloading and install the Odin compiler and libraries.
     29 
     30 # Learning Odin
     31 Getting Started - https://odin-lang.org/docs/install/
     32 Getting Started with Odin. Downloading, installing, and getting your
     33 first program to compile and run.
     34 Overview of Odin - https://odin-lang.org/docs/overview/
     35 An overview of the Odin programming language and its features.
     36 Frequently Asked Questions (FAQ) - https://odin-lang.org/docs/faq/
     37 Answers to common questions about Odin.
     38 Packages - https://pkg.odin-lang.org/
     39 Documentation for all the official packages part of the
     40 core and vendor library collections.
     41 Nightly Builds - https://odin-lang.org/docs/nightly/
     42 Get the latest nightly builds of Odin.
     43 More Odin Examples - https://github.com/odin-lang/examples
     44 This repository contains examples of how certain things can be accomplished
     45 in idiomatic Odin, allowing you learn its semantics, as well as how to use
     46 parts of the core and vendor package collections.
     47 */
     48 
     49 the_basics :: proc() {
     50 fmt.println("\n# the basics")
     51 
     52 { // The Basics
     53 
     54 // os.args holds the path to the current executable and any arguments passed to it.
     55 if len(os.args) == 1 {
     56 fmt.printf("Hellope from %v.\n", os.args[0])
     57 } else if len(os.args) > 2 {
     58 fmt.printf("%v, %v! from %v.\n", os.args[1], os.args[2], os.args[0])
     59 }
     60 
     61 // Lexical elements and literals
     62 // A comment
     63 
     64 my_integer_variable: int // A comment for documentaton
     65 
     66 // Multi-line comments begin with /* and end with */. Multi-line comments can
     67 // also be nested (unlike in C):
     68 /*
     69 You can have any text or code here and
     70 have it be commented.
     71 /*
     72 NOTE: comments can be nested!
     73 */
     74 */
     75 
     76 // String literals are enclosed in double quotes and character literals in single quotes.
     77 // Special characters are escaped with a backslash \
     78 
     79 some_string := "This is a string"
     80 _ = 'A' // unicode codepoint literal
     81 _ = '\n'
     82 _ = "C:\\Windows\\notepad.exe"
     83 // Raw string literals are enclosed with single back ticks
     84 _ = `C:\Windows\notepad.exe`
     85 
     86 // The length of a string in bytes can be found using the built-in `len` procedure:
     87 _ = len("Foo")
     88 _ = len(some_string)
     89 
     90 
     91 // Numbers
     92 
     93 // Numerical literals are written similar to most other programming languages.
     94 // A useful feature in Odin is that underscores are allowed for better
     95 // readability: 1_000_000_000 (one billion). A number that contains a dot is a
     96 // floating point literal: 1.0e9 (one billion). If a number literal is suffixed
     97 // with i, is an imaginary number literal: 2i (2 multiply the square root of -1).
     98 
     99 // Binary literals are prefixed with 0b, octal literals with 0o, and hexadecimal
    100 // literals 0x. A leading zero does not produce an octal constant (unlike C).
    101 
    102 // In Odin, if a numeric constant can be represented by a type without
    103 // precision loss, it will automatically convert to that type.
    104 
    105 x: int = 1.0 // A float literal but it can be represented by an integer without precision loss
    106 // Constant literals are “untyped” which means that they can implicitly convert to a type.
    107 
    108 y: int // `y` is typed of type `int`
    109 y = 1  // `1` is an untyped integer literal which can implicitly convert to `int`
    110 
    111 z: f64 // `z` is typed of type `f64` (64-bit floating point number)
    112 z = 1  // `1` is an untyped integer literal which can be implicitly converted to `f64`
    113 // No need for any suffixes or decimal places like in other languages
    114 // (with the exception of negative zero, which must be given as `-0.0`)
    115 // CONSTANTS JUST WORK!!!
    116 
    117 
    118 // Assignment statements
    119 h: int = 123 // declares a new variable `h` with type `int` and assigns a value to it
    120 h = 637 // assigns a new value to `h`
    121 
    122 // `=` is the assignment operator
    123 
    124 // You can assign multiple variables with it:
    125 a, b := 1, "hello" // declares `a` and `b` and infers the types from the assignments
    126 b, a = "byte", 0
    127 
    128 // Note: `:=` is two tokens, `:` and `=`. The following are equivalent,
    129 /*
    130 i: int = 123
    131 i:     = 123
    132 i := 123
    133 */
    134 
    135 // Constant declarations
    136 // Constants are entities (symbols) which have an assigned value.
    137 // The constant’s value cannot be changed.
    138 // The constant’s value must be able to be evaluated at compile time:
    139 X :: "what" // constant `X` has the untyped string value "what"
    140 
    141 // Constants can be explicitly typed like a variable declaration:
    142 Y : int : 123
    143 Z :: Y + 7 // constant computations are possible
    144 
    145 _ = my_integer_variable
    146 _ = x
    147 }
    148 }
    149 
    150 control_flow :: proc() {
    151 fmt.println("\n# control flow")
    152 { // Control flow
    153 // For loop
    154 // Odin has only one loop statement, the `for` loop
    155 
    156 // Basic for loop
    157 for i := 0; i < 10; i += 1 {
    158 fmt.println(i)
    159 }
    160 
    161 // NOTE: Unlike other languages like C, there are no parentheses `( )` surrounding the three components.
    162 // Braces `{ }` or a `do` are always required
    163 for i := 0; i < 10; i += 1 { }
    164 // for i := 0; i < 10; i += 1 do fmt.print()
    165 
    166 // The initial and post statements are optional
    167 i := 0
    168 for ; i < 10; {
    169 i += 1
    170 }
    171 
    172 // These semicolons can be dropped. This `for` loop is equivalent to C's `while` loop
    173 i = 0
    174 for i < 10 {
    175 i += 1
    176 }
    177 
    178 // If the condition is omitted, an infinite loop is produced:
    179 for {
    180 break
    181 }
    182 
    183 // Range-based for loop
    184 // The basic for loop
    185 for j := 0; j < 10; j += 1 {
    186 fmt.println(j)
    187 }
    188 // can also be written
    189 for j in 0..<10 {
    190 fmt.println(j)
    191 }
    192 for j in 0..=9 {
    193 fmt.println(j)
    194 }
    195 
    196 // Certain built-in types can be iterated over
    197 some_string := "Hello, 世界"
    198 for character in some_string { // Strings are assumed to be UTF-8
    199 fmt.println(character)
    200 }
    201 
    202 some_array := [3]int{1, 4, 9}
    203 for value in some_array {
    204 fmt.println(value)
    205 }
    206 
    207 some_slice := []int{1, 4, 9}
    208 for value in some_slice {
    209 fmt.println(value)
    210 }
    211 
    212 some_dynamic_array := [dynamic]int{1, 4, 9}
    213 defer delete(some_dynamic_array)
    214 for value in some_dynamic_array {
    215 fmt.println(value)
    216 }
    217 
    218 
    219 some_map := map[string]int{"A" = 1, "C" = 9, "B" = 4}
    220 defer delete(some_map)
    221 for key in some_map {
    222 fmt.println(key)
    223 }
    224 
    225 // Alternatively a second index value can be added
    226 for character, index in some_string {
    227 fmt.println(index, character)
    228 }
    229 for value, index in some_array {
    230 fmt.println(index, value)
    231 }
    232 for value, index in some_slice {
    233 fmt.println(index, value)
    234 }
    235 for value, index in some_dynamic_array {
    236 fmt.println(index, value)
    237 }
    238 for key, value in some_map {
    239 fmt.println(key, value)
    240 }
    241 
    242 // The iterated values are copies and cannot be written to.
    243 // The following idiom is useful for iterating over a container in a by-reference manner:
    244 for _, idx in some_slice {
    245 some_slice[idx] = (idx+1)*(idx+1)
    246 }
    247 
    248 
    249 // If statements
    250 x := 123
    251 if x >= 0 {
    252 fmt.println("x is positive")
    253 }
    254 
    255 if y := -34; y < 0 {
    256 fmt.println("y is negative")
    257 }
    258 
    259 if y := 123; y < 0 {
    260 fmt.println("y is negative")
    261 } else if y == 0 {
    262 fmt.println("y is zero")
    263 } else {
    264 fmt.println("y is positive")
    265 }
    266 
    267 // Switch statement
    268 // A switch statement is another way to write a sequence of if-else statements.
    269 // In Odin, the default case is denoted as a case without any expression.
    270 
    271 #partial switch arch := ODIN_ARCH; arch {
    272 case .i386:
    273 fmt.println("32-bit")
    274 case .amd64:
    275 fmt.println("64-bit")
    276 case: // default
    277 fmt.println("Unsupported architecture")
    278 }
    279 
    280 // Odin’s `switch` is like one in C or C++, except that Odin only runs the selected case.
    281 // This means that a `break` statement is not needed at the end of each case.
    282 // Another important difference is that the case values need not be integers nor constants.
    283 
    284 // To achieve a C-like fall through into the next case block, the keyword `fallthrough` can be used.
    285 one_angry_dwarf :: proc() -> int {
    286 fmt.println("one_angry_dwarf was called")
    287 return 1
    288 }
    289 
    290 switch j := 0; j {
    291 case 0:
    292 case one_angry_dwarf():
    293 }
    294 
    295 // A switch statement without a condition is the same as `switch true`.
    296 // This can be used to write a clean and long if-else chain and have the
    297 // ability to break if needed
    298 
    299 switch {
    300 case x < 0:
    301 fmt.println("x is negative")
    302 case x == 0:
    303 fmt.println("x is zero")
    304 case:
    305 fmt.println("x is positive")
    306 }
    307 
    308 // A `switch` statement can also use ranges like a range-based loop:
    309 switch c := 'j'; c {
    310 case 'A'..='Z', 'a'..='z', '0'..='9':
    311 fmt.println("c is alphanumeric")
    312 }
    313 
    314 switch x {
    315 case 0..<10:
    316 fmt.println("units")
    317 case 10..<13:
    318 fmt.println("pre-teens")
    319 case 13..<20:
    320 fmt.println("teens")
    321 case 20..<30:
    322 fmt.println("twenties")
    323 }
    324 }
    325 
    326 { // Defer statement
    327 // A defer statement defers the execution of a statement until the end of
    328 // the scope it is in.
    329 
    330 // The following will print 4 then 234:
    331 {
    332 x := 123
    333 defer fmt.println(x)
    334 {
    335 defer x = 4
    336 x = 2
    337 }
    338 fmt.println(x)
    339 
    340 x = 234
    341 }
    342 
    343 // You can defer an entire block too:
    344 {
    345 bar :: proc() {}
    346 
    347 defer {
    348 fmt.println("1")
    349 fmt.println("2")
    350 }
    351 
    352 cond := false
    353 defer if cond {
    354 bar()
    355 }
    356 }
    357 
    358 // Defer statements are executed in the reverse order that they were declared:
    359 {
    360 defer fmt.println("1")
    361 defer fmt.println("2")
    362 defer fmt.println("3")
    363 }
    364 // Will print 3, 2, and then 1.
    365 
    366 if false {
    367 f, err := os.open("my_file.txt")
    368 if err != nil {
    369 // handle error
    370 }
    371 defer os.close(f)
    372 // rest of code
    373 }
    374 }
    375 
    376 { // When statement
    377 /*
    378 The when statement is almost identical to the if statement but with some differences:
    379 
    380 * Each condition must be a constant expression as a when
    381 statement is evaluated at compile time.
    382 * The statements within a branch do not create a new scope
    383 * The compiler checks the semantics and code only for statements
    384 that belong to the first condition that is true
    385 * An initial statement is not allowed in a when statement
    386 * when statements are allowed at file scope
    387 */
    388 
    389 // Example
    390 when ODIN_ARCH == .i386 {
    391 fmt.println("32 bit")
    392 } else when ODIN_ARCH == .amd64 {
    393 fmt.println("64 bit")
    394 } else {
    395 fmt.println("Unknown architecture")
    396 }
    397 // The when statement is very useful for writing platform specific code.
    398 // This is akin to the #if construct in C’s preprocessor however, in Odin,
    399 // it is type checked.
    400 }
    401 
    402 { // Branch statements
    403 cond, cond1, cond2 := false, false, false
    404 one_step :: proc() { fmt.println("one_step") }
    405 beyond :: proc() { fmt.println("beyond") }
    406 
    407 // Break statement
    408 for cond {
    409 switch {
    410 case:
    411 if cond {
    412 break // break out of the `switch` statement
    413 }
    414 }
    415 
    416 break // break out of the `for` statement
    417 }
    418 
    419 loop: for cond1 {
    420 for cond2 {
    421 break loop // leaves both loops
    422 }
    423 }
    424 
    425 // Continue statement
    426 for cond {
    427 if cond2 {
    428 continue
    429 }
    430 fmt.println("Hellope")
    431 }
    432 
    433 // Fallthrough statement
    434 
    435 // Odin’s switch is like one in C or C++, except that Odin only runs the selected
    436 // case. This means that a break statement is not needed at the end of each case.
    437 // Another important difference is that the case values need not be integers nor
    438 // constants.
    439 
    440 // fallthrough can be used to explicitly fall through into the next case block:
    441 
    442 switch i := 0; i {
    443 case 0:
    444 one_step()
    445 fallthrough
    446 case 1:
    447 beyond()
    448 }
    449 }
    450 }
    451 
    452 
    453 named_proc_return_parameters :: proc() {
    454 fmt.println("\n# named proc return parameters")
    455 
    456 foo0 :: proc() -> int {
    457 return 123
    458 }
    459 foo1 :: proc() -> (a: int) {
    460 a = 123
    461 return
    462 }
    463 foo2 :: proc() -> (a, b: int) {
    464 // Named return values act like variables within the scope
    465 a = 321
    466 b = 567
    467 return b, a
    468 }
    469 fmt.println("foo0 =", foo0()) // 123
    470 fmt.println("foo1 =", foo1()) // 123
    471 fmt.println("foo2 =", foo2()) // 567 321
    472 }
    473 
    474 variadic_procedures :: proc() {
    475 fmt.println("\n# variadic procedures")
    476 sum :: proc(nums: ..int, init_value:= 0) -> (result: int) {
    477 result = init_value
    478 for n in nums {
    479 result += n
    480 }
    481 return
    482 }
    483 fmt.println("sum(()) =", sum())
    484 fmt.println("sum(1, 2) =", sum(1, 2))
    485 fmt.println("sum(1, 2, 3, 4, 5) =", sum(1, 2, 3, 4, 5))
    486 fmt.println("sum(1, 2, 3, 4, 5, init_value = 5) =", sum(1, 2, 3, 4, 5, init_value = 5))
    487 
    488 // pass a slice as varargs
    489 odds := []int{1, 3, 5}
    490 fmt.println("odds =", odds)
    491 fmt.println("sum(..odds) =", sum(..odds))
    492 fmt.println("sum(..odds, init_value = 5) =", sum(..odds, init_value = 5))
    493 }
    494 
    495 
    496 explicit_procedure_overloading :: proc() {
    497 fmt.println("\n# explicit procedure overloading")
    498 
    499 add_ints :: proc(a, b: int) -> int {
    500 x := a + b
    501 fmt.println("add_ints", x)
    502 return x
    503 }
    504 add_floats :: proc(a, b: f32) -> f32 {
    505 x := a + b
    506 fmt.println("add_floats", x)
    507 return x
    508 }
    509 add_numbers :: proc(a: int, b: f32, c: u8) -> int {
    510 x := int(a) + int(b) + int(c)
    511 fmt.println("add_numbers", x)
    512 return x
    513 }
    514 
    515 add :: proc{add_ints, add_floats, add_numbers}
    516 
    517 add(int(1), int(2))
    518 add(f32(1), f32(2))
    519 add(int(1), f32(2), u8(3))
    520 
    521 add(1, 2)     // untyped ints coerce to int tighter than f32
    522 add(1.0, 2.0) // untyped floats coerce to f32 tighter than int
    523 add(1, 2, 3)  // three parameters
    524 
    525 // Ambiguous answers
    526 // add(1.0, 2)
    527 // add(1, 2.0)
    528 }
    529 
    530 struct_type :: proc() {
    531 fmt.println("\n# struct type")
    532 // A struct is a record type in Odin. It is a collection of fields.
    533 // Struct fields are accessed by using a dot:
    534 {
    535 Vector2 :: struct {
    536 x: f32,
    537 y: f32,
    538 }
    539 v := Vector2{1, 2}
    540 v.x = 4
    541 fmt.println(v.x)
    542 
    543 // Struct fields can be accessed through a struct pointer:
    544 
    545 v = Vector2{1, 2}
    546 p := &v
    547 p.x = 1335
    548 fmt.println(v)
    549 
    550 // We could write p^.x, however, it is nice to abstract the ability
    551 // to not explicitly dereference the pointer. This is very useful when
    552 // refactoring code to use a pointer rather than a value, and vice versa.
    553 }
    554 {
    555 // A struct literal can be denoted by providing the struct’s type
    556 // followed by {}. A struct literal must either provide all the
    557 // arguments or none:
    558 Vector3 :: struct {
    559 x, y, z: f32,
    560 }
    561 v: Vector3
    562 v = Vector3{} // Zero value
    563 v = Vector3{1, 4, 9}
    564 
    565 // You can list just a subset of the fields if you specify the
    566 // field by name (the order of the named fields does not matter):
    567 v = Vector3{z=1, y=2}
    568 assert(v.x == 0)
    569 assert(v.y == 2)
    570 assert(v.z == 1)
    571 }
    572 {
    573 // Structs can tagged with different memory layout and alignment requirements:
    574 
    575 a :: struct #align(4)  {} // align to 4 bytes
    576 b :: struct #packed    {} // remove padding between fields
    577 c :: struct #raw_union {} // all fields share the same offset (0). This is the same as C's union
    578 }
    579 
    580 }
    581 
    582 
    583 union_type :: proc() {
    584 fmt.println("\n# union type")
    585 {
    586 val: union{int, bool}
    587 val = 137
    588 if i, ok := val.(int); ok {
    589 fmt.println(i)
    590 }
    591 val = true
    592 fmt.println(val)
    593 
    594 val = nil
    595 
    596 switch v in val {
    597 case int:  fmt.println("int",  v)
    598 case bool: fmt.println("bool", v)
    599 case:      fmt.println("nil")
    600 }
    601 }
    602 {
    603 // There is a duality between `any` and `union`
    604 // An `any` has a pointer to the data and allows for any type (open)
    605 // A `union` has as binary blob to store the data and allows only certain types (closed)
    606 // The following code is with `any` but has the same syntax
    607 val: any
    608 val = 137
    609 if i, ok := val.(int); ok {
    610 fmt.println(i)
    611 }
    612 val = true
    613 fmt.println(val)
    614 
    615 val = nil
    616 
    617 switch v in val {
    618 case int:  fmt.println("int",  v)
    619 case bool: fmt.println("bool", v)
    620 case:      fmt.println("nil")
    621 }
    622 }
    623 
    624 Vector3 :: distinct [3]f32
    625 Quaternion :: distinct quaternion128
    626 
    627 // More realistic examples
    628 {
    629 // NOTE(bill): For the above basic examples, you may not have any
    630 // particular use for it. However, my main use for them is not for these
    631 // simple cases. My main use is for hierarchical types. Many prefer
    632 // subtyping, embedding the base data into the derived types. Below is
    633 // an example of this for a basic game Entity.
    634 
    635 Entity :: struct {
    636 id:          u64,
    637 name:        string,
    638 position:    Vector3,
    639 orientation: Quaternion,
    640 
    641 derived: any,
    642 }
    643 
    644 Frog :: struct {
    645 using entity: Entity,
    646 jump_height:  f32,
    647 }
    648 
    649 Monster :: struct {
    650 using entity: Entity,
    651 is_robot:     bool,
    652 is_zombie:    bool,
    653 }
    654 
    655 // See `parametric_polymorphism` procedure for details
    656 new_entity :: proc($T: typeid) -> ^Entity {
    657 t := new(T)
    658 t.derived = t^
    659 return t
    660 }
    661 
    662 entity := new_entity(Monster)
    663 
    664 switch e in entity.derived {
    665 case Frog:
    666 fmt.println("Ribbit")
    667 case Monster:
    668 if e.is_robot  { fmt.println("Robotic") }
    669 if e.is_zombie { fmt.println("Grrrr!")  }
    670 fmt.println("I'm a monster")
    671 }
    672 }
    673 
    674 {
    675 // NOTE(bill): A union can be used to achieve something similar. Instead
    676 // of embedding the base data into the derived types, the derived data
    677 // in embedded into the base type. Below is the same example of the
    678 // basic game Entity but using an union.
    679 
    680 Entity :: struct {
    681 id:          u64,
    682 name:        string,
    683 position:    Vector3,
    684 orientation: Quaternion,
    685 
    686 derived: union {Frog, Monster},
    687 }
    688 
    689 Frog :: struct {
    690 using entity: ^Entity,
    691 jump_height:  f32,
    692 }
    693 
    694 Monster :: struct {
    695 using entity: ^Entity,
    696 is_robot:     bool,
    697 is_zombie:    bool,
    698 }
    699 
    700 // See `parametric_polymorphism` procedure for details
    701 new_entity :: proc($T: typeid) -> ^Entity {
    702 t := new(Entity)
    703 t.derived = T{entity = t}
    704 return t
    705 }
    706 
    707 entity := new_entity(Monster)
    708 
    709 switch e in entity.derived {
    710 case Frog:
    711 fmt.println("Ribbit")
    712 case Monster:
    713 if e.is_robot  { fmt.println("Robotic") }
    714 if e.is_zombie { fmt.println("Grrrr!")  }
    715 }
    716 
    717 // NOTE(bill): As you can see, the usage code has not changed, only its
    718 // memory layout. Both approaches have their own advantages but they can
    719 // be used together to achieve different results. The subtyping approach
    720 // can allow for a greater control of the memory layout and memory
    721 // allocation, e.g. storing the derivatives together. However, this is
    722 // also its disadvantage. You must either preallocate arrays for each
    723 // derivative separation (which can be easily missed) or preallocate a
    724 // bunch of "raw" memory; determining the maximum size of the derived
    725 // types would require the aid of metaprogramming. Unions solve this
    726 // particular problem as the data is stored with the base data.
    727 // Therefore, it is possible to preallocate, e.g. [100]Entity.
    728 
    729 // It should be noted that the union approach can have the same memory
    730 // layout as the any and with the same type restrictions by using a
    731 // pointer type for the derivatives.
    732 
    733 /*
    734 Entity :: struct {
    735 ...
    736 derived: union{^Frog, ^Monster},
    737 }
    738 
    739 Frog :: struct {
    740 using entity: Entity,
    741 ...
    742 }
    743 Monster :: struct {
    744 using entity: Entity,
    745 ...
    746 
    747 }
    748 new_entity :: proc(T: type) -> ^Entity {
    749 t := new(T)
    750 t.derived = t
    751 return t
    752 }
    753 */
    754 }
    755 }
    756 
    757 using_statement :: proc() {
    758 // IMPORTANT NOTE: `using` as a statement is an opt-in feature which can be abled
    759 // by adding `#+feature using-stmt` to be beginning of the file
    760 //
    761 // `using` as a struct field modifier remains available always
    762 
    763 fmt.println("\n# using statement")
    764 // using can used to bring entities declared in a scope/namespace
    765 // into the current scope. This can be applied to import names, struct
    766 // fields, procedure fields, and struct values.
    767 
    768 Vector3 :: struct{x, y, z: f32}
    769 {
    770 Entity :: struct {
    771 position: Vector3,
    772 orientation: quaternion128,
    773 }
    774 
    775 // It can used like this:
    776 foo0 :: proc(entity: ^Entity) {
    777 fmt.println(entity.position.x, entity.position.y, entity.position.z)
    778 }
    779 
    780 // The entity members can be brought into the procedure scope by using it:
    781 foo1 :: proc(entity: ^Entity) {
    782 using entity
    783 fmt.println(position.x, position.y, position.z)
    784 }
    785 
    786 // The using can be applied to the parameter directly:
    787 foo2 :: proc(using entity: ^Entity) {
    788 fmt.println(position.x, position.y, position.z)
    789 }
    790 
    791 // It can also be applied to sub-fields:
    792 foo3 :: proc(entity: ^Entity) {
    793 using entity.position
    794 fmt.println(x, y, z)
    795 }
    796 }
    797 {
    798 // We can also apply the using statement to the struct fields directly,
    799 // making all the fields of position appear as if they on Entity itself:
    800 Entity :: struct {
    801 using position: Vector3,
    802 orientation: quaternion128,
    803 }
    804 foo :: proc(entity: ^Entity) {
    805 fmt.println(entity.x, entity.y, entity.z)
    806 }
    807 
    808 
    809 // Subtype polymorphism
    810 // It is possible to get subtype polymorphism, similar to inheritance-like
    811 // functionality in C++, but without the requirement of vtables or unknown
    812 // struct layout:
    813 
    814 Colour :: struct {r, g, b, a: u8}
    815 Frog :: struct {
    816 ribbit_volume: f32,
    817 using entity: Entity,
    818 colour: Colour,
    819 }
    820 
    821 frog: Frog
    822 // Both work
    823 foo(&frog.entity)
    824 foo(&frog)
    825 frog.x = 123
    826 
    827 // Note: using can be applied to arbitrarily many things, which allows
    828 // the ability to have multiple subtype polymorphism (but also its issues).
    829 
    830 // Note: using’d fields can still be referred by name.
    831 }
    832 }
    833 
    834 
    835 implicit_context_system :: proc() {
    836 fmt.println("\n# implicit context system")
    837 // In each scope, there is an implicit value named context. This
    838 // context variable is local to each scope and is implicitly passed
    839 // by pointer to any procedure call in that scope (if the procedure
    840 // has the Odin calling convention).
    841 
    842 // The main purpose of the implicit context system is for the ability
    843 // to intercept third-party code and libraries and modify their
    844 // functionality. One such case is modifying how a library allocates
    845 // something or logs something. In C, this was usually achieved with
    846 // the library defining macros which could be overridden so that the
    847 // user could define what he wanted. However, not many libraries
    848 // supported this in many languages by default which meant intercepting
    849 // third-party code to see what it does and to change how it does it is
    850 // not possible.
    851 
    852 c := context // copy the current scope's context
    853 
    854 context.user_index = 456
    855 {
    856 context.allocator = my_custom_allocator()
    857 context.user_index = 123
    858 what_a_fool_believes() // the `context` for this scope is implicitly passed to `what_a_fool_believes`
    859 }
    860 
    861 // `context` value is local to the scope it is in
    862 assert(context.user_index == 456)
    863 
    864 what_a_fool_believes :: proc() {
    865 c := context // this `context` is the same as the parent procedure that it was called from
    866 // From this example, context.user_index == 123
    867 // A context.allocator is assigned to the return value of `my_custom_allocator()`
    868 assert(context.user_index == 123)
    869 
    870 // The memory management procedure use the `context.allocator` by
    871 // default unless explicitly specified otherwise
    872 china_grove := new(int)
    873 free(china_grove)
    874 
    875 _ = c
    876 }
    877 
    878 my_custom_allocator :: mem.nil_allocator
    879 _ = c
    880 
    881 // By default, the context value has default values for its parameters which is
    882 // decided in the package runtime. What the defaults are are compiler specific.
    883 
    884 // To see what the implicit context value contains, please see the following
    885 // definition in package runtime.
    886 }
    887 
    888 parametric_polymorphism :: proc() {
    889 fmt.println("\n# parametric polymorphism")
    890 
    891 print_value :: proc(value: $T) {
    892 fmt.printf("print_value: %T %v\n", value, value)
    893 }
    894 
    895 v1: int    = 1
    896 v2: f32    = 2.1
    897 v3: f64    = 3.14
    898 v4: string = "message"
    899 
    900 print_value(v1)
    901 print_value(v2)
    902 print_value(v3)
    903 print_value(v4)
    904 
    905 fmt.println()
    906 
    907 add :: proc(p, q: $T) -> T {
    908 x: T = p + q
    909 return x
    910 }
    911 
    912 a := add(3, 4)
    913 fmt.printf("a: %T = %v\n", a, a)
    914 
    915 b := add(3.2, 4.3)
    916 fmt.printf("b: %T = %v\n", b, b)
    917 
    918 // This is how `new` is implemented
    919 alloc_type :: proc($T: typeid) -> ^T {
    920 t := cast(^T)mem.alloc(size_of(T), align_of(T))
    921 t^ = T{} // Use default initialization value
    922 return t
    923 }
    924 
    925 copy_slice :: proc(dst, src: []$T) -> int {
    926 n := min(len(dst), len(src))
    927 if n > 0 {
    928 mem.copy(&dst[0], &src[0], n*size_of(T))
    929 }
    930 return n
    931 }
    932 
    933 double_params :: proc(a: $A, b: $B) -> A {
    934 return a + A(b)
    935 }
    936 
    937 fmt.println(double_params(12, 1.345))
    938 
    939 
    940 
    941 { // Polymorphic Types and Type Specialization
    942 Table_Slot :: struct($Key, $Value: typeid) {
    943 occupied: bool,
    944 hash:     u32,
    945 key:      Key,
    946 value:    Value,
    947 }
    948 TABLE_SIZE_MIN :: 32
    949 Table :: struct($Key, $Value: typeid) {
    950 count:     int,
    951 allocator: mem.Allocator,
    952 slots:     []Table_Slot(Key, Value),
    953 }
    954 
    955 // Only allow types that are specializations of a (polymorphic) slice
    956 make_slice :: proc($T: typeid/[]$E, len: int) -> T {
    957 return make(T, len)
    958 }
    959 
    960 // Only allow types that are specializations of `Table`
    961 allocate :: proc(table: ^$T/Table, capacity: int) {
    962 c := context
    963 if table.allocator.procedure != nil {
    964 c.allocator = table.allocator
    965 }
    966 context = c
    967 
    968 table.slots = make_slice(type_of(table.slots), max(capacity, TABLE_SIZE_MIN))
    969 }
    970 
    971 expand :: proc(table: ^$T/Table) {
    972 c := context
    973 if table.allocator.procedure != nil {
    974 c.allocator = table.allocator
    975 }
    976 context = c
    977 
    978 old_slots := table.slots
    979 defer delete(old_slots)
    980 
    981 cap := max(2*len(table.slots), TABLE_SIZE_MIN)
    982 allocate(table, cap)
    983 
    984 for s in old_slots {
    985 if s.occupied {
    986 put(table, s.key, s.value)
    987 }
    988 }
    989 }
    990 
    991 // Polymorphic determination of a polymorphic struct
    992 // put :: proc(table: ^$T/Table, key: T.Key, value: T.Value) {
    993 put :: proc(table: ^Table($Key, $Value), key: Key, value: Value) {
    994 hash := get_hash(key) // Ad-hoc method which would fail in a different scope
    995 index := find_index(table, key, hash)
    996 if index < 0 {
    997 if f64(table.count) >= 0.75*f64(len(table.slots)) {
    998 expand(table)
    999 }
   1000 assert(table.count <= len(table.slots))
   1001 
   1002 index = int(hash % u32(len(table.slots)))
   1003 
   1004 for table.slots[index].occupied {
   1005 if index += 1; index >= len(table.slots) {
   1006 index = 0
   1007 }
   1008 }
   1009 
   1010 table.count += 1
   1011 }
   1012 
   1013 slot := &table.slots[index]
   1014 slot.occupied = true
   1015 slot.hash     = hash
   1016 slot.key      = key
   1017 slot.value    = value
   1018 }
   1019 
   1020 
   1021 // find :: proc(table: ^$T/Table, key: T.Key) -> (T.Value, bool) {
   1022 find :: proc(table: ^Table($Key, $Value), key: Key) -> (Value, bool) {
   1023 hash := get_hash(key)
   1024 index := find_index(table, key, hash)
   1025 if index < 0 {
   1026 return Value{}, false
   1027 }
   1028 return table.slots[index].value, true
   1029 }
   1030 
   1031 find_index :: proc(table: ^Table($Key, $Value), key: Key, hash: u32) -> int {
   1032 if len(table.slots) <= 0 {
   1033 return -1
   1034 }
   1035 
   1036 index := int(hash % u32(len(table.slots)))
   1037 for table.slots[index].occupied {
   1038 if table.slots[index].hash == hash {
   1039 if table.slots[index].key == key {
   1040 return index
   1041 }
   1042 }
   1043 
   1044 if index += 1; index >= len(table.slots) {
   1045 index = 0
   1046 }
   1047 }
   1048 
   1049 return -1
   1050 }
   1051 
   1052 get_hash :: proc(s: string) -> u32 { // fnv32a
   1053 h: u32 = 0x811c9dc5
   1054 for i in 0..<len(s) {
   1055 h = (h ~ u32(s[i])) * 0x01000193
   1056 }
   1057 return h
   1058 }
   1059 
   1060 
   1061 table: Table(string, int)
   1062 
   1063 for i in 0..=36 { put(&table, "Hellope", i) }
   1064 for i in 0..=42 { put(&table, "World!",  i) }
   1065 
   1066 found, _ := find(&table, "Hellope")
   1067 fmt.printf("`found` is %v\n", found)
   1068 
   1069 found, _ = find(&table, "World!")
   1070 fmt.printf("`found` is %v\n", found)
   1071 
   1072 // I would not personally design a hash table like this in production
   1073 // but this is a nice basic example
   1074 // A better approach would either use a `u64` or equivalent for the key
   1075 // and let the user specify the hashing function or make the user store
   1076 // the hashing procedure with the table
   1077 }
   1078 
   1079 { // Parametric polymorphic union
   1080 Error :: enum {
   1081 Foo0,
   1082 Foo1,
   1083 Foo2,
   1084 Foo3,
   1085 }
   1086 Para_Union :: union($T: typeid) {T, Error}
   1087 r: Para_Union(int)
   1088 fmt.println(typeid_of(type_of(r)))
   1089 
   1090 fmt.println(r)
   1091 r = 123
   1092 fmt.println(r)
   1093 r = Error.Foo0 // r = .Foo0 is allow too, see implicit selector expressions below
   1094 fmt.println(r)
   1095 }
   1096 
   1097 { // Polymorphic names
   1098 foo :: proc($N: $I, $T: typeid) -> (res: [N]T) {
   1099 // `N` is the constant value passed
   1100 // `I` is the type of N
   1101 // `T` is the type passed
   1102 fmt.printf("Generating an array of type %v from the value %v of type %v\n",
   1103 typeid_of(type_of(res)), N, typeid_of(I))
   1104 for i in 0..<N {
   1105 res[i] = T(i*i)
   1106 }
   1107 return
   1108 }
   1109 
   1110 T :: int
   1111 array := foo(4, T)
   1112 for v, i in array {
   1113 assert(v == T(i*i))
   1114 }
   1115 
   1116 // Matrix multiplication
   1117 mul :: proc(a: [$M][$N]$T, b: [N][$P]T) -> (c: [M][P]T) {
   1118 for i in 0..<M {
   1119 for j in 0..<P {
   1120 for k in 0..<N {
   1121 c[i][j] += a[i][k] * b[k][j]
   1122 }
   1123 }
   1124 }
   1125 return
   1126 }
   1127 
   1128 x := [2][3]f32{
   1129 {1, 2, 3},
   1130 {3, 2, 1},
   1131 }
   1132 y := [3][2]f32{
   1133 {0, 8},
   1134 {6, 2},
   1135 {8, 4},
   1136 }
   1137 z := mul(x, y)
   1138 assert(z == {{36, 24}, {20, 32}})
   1139 }
   1140 }
   1141 
   1142 
   1143 prefix_table := [?]string{
   1144 "White",
   1145 "Red",
   1146 "Green",
   1147 "Blue",
   1148 "Octarine",
   1149 "Black",
   1150 }
   1151 
   1152 print_mutex := b64(false)
   1153 
   1154 @(disabled=!thread.IS_SUPPORTED)
   1155 threading_example :: proc() {
   1156 fmt.println("\n# threading_example")
   1157 
   1158 did_acquire :: proc(m: ^b64) -> (acquired: bool) {
   1159 res, ok := intrinsics.atomic_compare_exchange_strong(m, false, true)
   1160 return ok && res == false
   1161 }
   1162 
   1163 { // Basic Threads
   1164 fmt.println("\n## Basic Threads")
   1165 worker_proc :: proc(t: ^thread.Thread) {
   1166 for iteration in 1..=5 {
   1167 fmt.printf("Thread %d is on iteration %d\n", t.user_index, iteration)
   1168 fmt.printf("`%s`: iteration %d\n", prefix_table[t.user_index], iteration)
   1169 time.sleep(1 * time.Millisecond)
   1170 }
   1171 }
   1172 
   1173 threads := make([dynamic]^thread.Thread, 0, len(prefix_table))
   1174 defer delete(threads)
   1175 
   1176 for _ in prefix_table {
   1177 if t := thread.create(worker_proc); t != nil {
   1178 t.init_context = context
   1179 t.user_index = len(threads)
   1180 append(&threads, t)
   1181 thread.start(t)
   1182 }
   1183 }
   1184 
   1185 for len(threads) > 0 {
   1186 for i := 0; i < len(threads); /**/ {
   1187 if t := threads[i]; thread.is_done(t) {
   1188 fmt.printf("Thread %d is done\n", t.user_index)
   1189 thread.destroy(t)
   1190 
   1191 ordered_remove(&threads, i)
   1192 } else {
   1193 i += 1
   1194 }
   1195 }
   1196 }
   1197 }
   1198 
   1199 { // Thread Pool
   1200 fmt.println("\n## Thread Pool")
   1201 task_proc :: proc(t: thread.Task) {
   1202 index := t.user_index % len(prefix_table)
   1203 for iteration in 1..=5 {
   1204 for !did_acquire(&print_mutex) { thread.yield() } // Allow one thread to print at a time.
   1205 
   1206 fmt.printf("Worker Task %d is on iteration %d\n", t.user_index, iteration)
   1207 fmt.printf("`%s`: iteration %d\n", prefix_table[index], iteration)
   1208 
   1209 print_mutex = false
   1210 
   1211 time.sleep(1 * time.Millisecond)
   1212 }
   1213 }
   1214 
   1215 N :: 3
   1216 
   1217 pool: thread.Pool
   1218 thread.pool_init(&pool, allocator=context.allocator, thread_count=N)
   1219 defer thread.pool_destroy(&pool)
   1220 
   1221 
   1222 for i in 0..<30 {
   1223 // be mindful of the allocator used for tasks. The allocator needs to be thread safe, or be owned by the task for exclusive use
   1224 thread.pool_add_task(&pool, allocator=context.allocator, procedure=task_proc, data=nil, user_index=i)
   1225 }
   1226 
   1227 thread.pool_start(&pool)
   1228 thread.pool_finish(&pool)
   1229 }
   1230 }
   1231 
   1232 
   1233 array_programming :: proc() {
   1234 fmt.println("\n# array programming")
   1235 {
   1236 a := [3]f32{1, 2, 3}
   1237 b := [3]f32{5, 6, 7}
   1238 c := a * b
   1239 d := a + b
   1240 e := 1 +  (c - d) / 2
   1241 fmt.printf("%.1f\n", e) // [0.5, 3.0, 6.5]
   1242 }
   1243 
   1244 {
   1245 a := [3]f32{1, 2, 3}
   1246 b := swizzle(a, 2, 1, 0)
   1247 assert(b == [3]f32{3, 2, 1})
   1248 
   1249 c := swizzle(a, 0, 0)
   1250 assert(c == [2]f32{1, 1})
   1251 assert(c == 1)
   1252 }
   1253 
   1254 {
   1255 Vector3 :: distinct [3]f32
   1256 a := Vector3{1, 2, 3}
   1257 b := Vector3{5, 6, 7}
   1258 c := (a * b)/2 + 1
   1259 d := c.x + c.y + c.z
   1260 fmt.printf("%.1f\n", d) // 22.0
   1261 
   1262 cross :: proc(a, b: Vector3) -> Vector3 {
   1263 i := swizzle(a, 1, 2, 0) * swizzle(b, 2, 0, 1)
   1264 j := swizzle(a, 2, 0, 1) * swizzle(b, 1, 2, 0)
   1265 return i - j
   1266 }
   1267 
   1268 cross_shorter :: proc(a, b: Vector3) -> Vector3 {
   1269 i := a.yzx * b.zxy
   1270 j := a.zxy * b.yzx
   1271 return i - j
   1272 }
   1273 
   1274 blah :: proc(a: Vector3) -> f32 {
   1275 return a.x + a.y + a.z
   1276 }
   1277 
   1278 x := cross(a, b)
   1279 fmt.println(x)
   1280 fmt.println(blah(x))
   1281 }
   1282 }
   1283 
   1284 map_type :: proc() {
   1285 fmt.println("\n# map type")
   1286 
   1287 m := make(map[string]int)
   1288 defer delete(m)
   1289 
   1290 m["Bob"] = 2
   1291 m["Ted"] = 5
   1292 fmt.println(m["Bob"])
   1293 
   1294 delete_key(&m, "Ted")
   1295 
   1296 // If an element of a key does not exist, the zero value of the
   1297 // element will be returned. To check to see if an element exists
   1298 // can be done in two ways:
   1299 elem, ok := m["Bob"]
   1300 exists := "Bob" in m
   1301 _, _ = elem, ok
   1302 _ = exists
   1303 }
   1304 
   1305 implicit_selector_expression :: proc() {
   1306 fmt.println("\n# implicit selector expression")
   1307 
   1308 Foo :: enum {A, B, C}
   1309 
   1310 f: Foo
   1311 f = Foo.A
   1312 f = .A
   1313 
   1314 BAR :: bit_set[Foo]{.B, .C}
   1315 
   1316 switch f {
   1317 case .A:
   1318 fmt.println("HITHER")
   1319 case .B:
   1320 if true do fmt.println("NEVER")
   1321 case .C:
   1322 fmt.println("FOREVER")
   1323 }
   1324 
   1325 my_map := make(map[Foo]int)
   1326 defer delete(my_map)
   1327 
   1328 my_map[.A] = 123
   1329 my_map[Foo.B] = 345
   1330 
   1331 fmt.println(my_map[.A] + my_map[Foo.B] + my_map[.C])
   1332 }
   1333 
   1334 
   1335 partial_switch :: proc() {
   1336 fmt.println("\n# partial_switch")
   1337 { // enum
   1338 Foo :: enum {
   1339 A,
   1340 B,
   1341 C,
   1342 D,
   1343 }
   1344 
   1345 f := Foo.A
   1346 switch f {
   1347 case .A: fmt.println("A")
   1348 case .B: fmt.println("B")
   1349 case .C: fmt.println("C")
   1350 case .D: fmt.println("D")
   1351 case:    fmt.println("?")
   1352 }
   1353 
   1354 #partial switch f {
   1355 case .A: fmt.println("A")
   1356 case .D: fmt.println("D")
   1357 }
   1358 }
   1359 { // union
   1360 Foo :: union {int, bool}
   1361 f: Foo = 123
   1362 switch _ in f {
   1363 case int:  fmt.println("int")
   1364 case bool: fmt.println("bool")
   1365 case:
   1366 }
   1367 
   1368 #partial switch _ in f {
   1369 case bool: fmt.println("bool")
   1370 }
   1371 }
   1372 }
   1373 
   1374 cstring_example :: proc() {
   1375 fmt.println("\n# cstring_example")
   1376 
   1377 W :: "Hellope"
   1378 X :: cstring(W)
   1379 Y :: string(X)
   1380 
   1381 w := W
   1382 _ = w
   1383 x: cstring = X
   1384 y: string = Y
   1385 z := string(x)
   1386 fmt.println(x, y, z)
   1387 fmt.println(len(x), len(y), len(z))
   1388 fmt.println(len(W), len(X), len(Y))
   1389 // IMPORTANT NOTE for cstring variables
   1390 // len(cstring) is O(N)
   1391 // cast(string)cstring is O(N)
   1392 }
   1393 
   1394 bit_set_type :: proc() {
   1395 fmt.println("\n# bit_set type")
   1396 
   1397 {
   1398 Day :: enum {
   1399 Sunday,
   1400 Monday,
   1401 Tuesday,
   1402 Wednesday,
   1403 Thursday,
   1404 Friday,
   1405 Saturday,
   1406 }
   1407 
   1408 Days :: distinct bit_set[Day]
   1409 WEEKEND :: Days{.Sunday, .Saturday}
   1410 
   1411 d: Days
   1412 d = {.Sunday, .Monday}
   1413 e := d + WEEKEND
   1414 e += {.Monday}
   1415 fmt.println(d, e)
   1416 
   1417 ok := .Saturday in e // `in` is only allowed for `map` and `bit_set` types
   1418 fmt.println(ok)
   1419 if .Saturday in e {
   1420 fmt.println("Saturday in", e)
   1421 }
   1422 X :: .Saturday in WEEKEND // Constant evaluation
   1423 fmt.println(X)
   1424 fmt.println("Cardinality:", card(e))
   1425 }
   1426 {
   1427 x: bit_set['A'..='Z']
   1428 #assert(size_of(x) == size_of(u32))
   1429 y: bit_set[0..=8; u16]
   1430 fmt.println(typeid_of(type_of(x))) // bit_set[A..=Z]
   1431 fmt.println(typeid_of(type_of(y))) // bit_set[0..=8; u16]
   1432 
   1433 x += {'F'}
   1434 assert('F' in x)
   1435 x -= {'F'}
   1436 assert('F' not_in x)
   1437 
   1438 y += {1, 4, 2}
   1439 assert(2 in y)
   1440 }
   1441 {
   1442 Letters :: bit_set['A'..='Z']
   1443 a := Letters{'A', 'B'}
   1444 b := Letters{'A', 'B', 'C', 'D', 'F'}
   1445 c := Letters{'A', 'B'}
   1446 
   1447 assert(a <= b) // 'a' is a subset of 'b'
   1448 assert(b >= a) // 'b' is a superset of 'a'
   1449 assert(a < b)  // 'a' is a strict subset of 'b'
   1450 assert(b > a)  // 'b' is a strict superset of 'a'
   1451 
   1452 assert(!(a < c)) // 'a' is a not strict subset of 'c'
   1453 assert(!(c > a)) // 'c' is a not strict superset of 'a'
   1454 }
   1455 }
   1456 
   1457 deferred_procedure_associations :: proc() {
   1458 fmt.println("\n# deferred procedure associations")
   1459 
   1460 @(deferred_out=closure)
   1461 open :: proc(s: string) -> bool {
   1462 fmt.println(s)
   1463 return true
   1464 }
   1465 
   1466 closure :: proc(ok: bool) {
   1467 fmt.println("Goodbye?", ok)
   1468 }
   1469 
   1470 if open("Welcome") {
   1471 fmt.println("Something in the middle, mate.")
   1472 }
   1473 }
   1474 
   1475 reflection :: proc() {
   1476 fmt.println("\n# reflection")
   1477 
   1478 Foo :: struct {
   1479 x: int    `tag1`,
   1480 y: string `json:"y_field"`,
   1481 z: bool, // no tag
   1482 }
   1483 
   1484 id := typeid_of(Foo)
   1485 names := reflect.struct_field_names(id)
   1486 types := reflect.struct_field_types(id)
   1487 tags  := reflect.struct_field_tags(id)
   1488 
   1489 assert(len(names) == len(types) && len(names) == len(tags))
   1490 
   1491 fmt.println("Foo :: struct {")
   1492 for tag, i in tags {
   1493 name, type := names[i], types[i]
   1494 if tag != "" {
   1495 fmt.printf("\t%s: %T `%s`,\n", name, type, tag)
   1496 } else {
   1497 fmt.printf("\t%s: %T,\n", name, type)
   1498 }
   1499 }
   1500 fmt.println("}")
   1501 
   1502 
   1503 for tag, i in tags {
   1504 if val, ok := reflect.struct_tag_lookup(tag, "json"); ok {
   1505 fmt.printf("json: %s -> %s\n", names[i], val)
   1506 }
   1507 }
   1508 }
   1509 
   1510 quaternions :: proc() {
   1511 // Not just an April Fool's Joke any more, but a fully working thing!
   1512 fmt.println("\n# quaternions")
   1513 
   1514 { // Quaternion operations
   1515 q := 1 + 2i + 3j + 4k
   1516 r := quaternion(real=5, imag=6, jmag=7, kmag=8)
   1517 t := q * r
   1518 fmt.printf("(%v) * (%v) = %v\n", q, r, t)
   1519 v := q / r
   1520 fmt.printf("(%v) / (%v) = %v\n", q, r, v)
   1521 u := q + r
   1522 fmt.printf("(%v) + (%v) = %v\n", q, r, u)
   1523 s := q - r
   1524 fmt.printf("(%v) - (%v) = %v\n", q, r, s)
   1525 }
   1526 { // The quaternion types
   1527 q128: quaternion128 // 4xf32
   1528 q256: quaternion256 // 4xf64
   1529 q128 = quaternion(w=1, x=0, y=0, z=0)
   1530 q256 = 1 // quaternion(x=0, y=0, z=0, w=1)
   1531 
   1532 // NOTE: The internal memory layout of a quaternion is xyzw
   1533 }
   1534 { // Built-in procedures
   1535 q := 1 + 2i + 3j + 4k
   1536 fmt.println("q =", q)
   1537 fmt.println("real(q) =", real(q))
   1538 fmt.println("imag(q) =", imag(q))
   1539 fmt.println("jmag(q) =", jmag(q))
   1540 fmt.println("kmag(q) =", kmag(q))
   1541 fmt.println("conj(q) =", conj(q))
   1542 fmt.println("abs(q)  =", abs(q))
   1543 }
   1544 { // Conversion of a complex type to a quaternion type
   1545 c := 1 + 2i
   1546 q := quaternion256(c)
   1547 fmt.println(c)
   1548 fmt.println(q)
   1549 }
   1550 { // Memory layout of Quaternions
   1551 q := 1 + 2i + 3j + 4k
   1552 a := transmute([4]f64)q
   1553 fmt.println("Quaternion memory layout: xyzw/(ijkr)")
   1554 fmt.println(q) // 1.000+2.000i+3.000j+4.000k
   1555 fmt.println(a) // [2.000, 3.000, 4.000, 1.000]
   1556 }
   1557 }
   1558 
   1559 unroll_for_statement :: proc() {
   1560 fmt.println("\n#'#unroll for' statements")
   1561 
   1562 // '#unroll for' works the same as if the 'inline' prefix did not
   1563 // exist but these ranged loops are explicitly unrolled which can
   1564 // be very very useful for certain optimizations
   1565 
   1566 fmt.println("Ranges")
   1567 #unroll for x, i in 1..<4 {
   1568 fmt.println(x, i)
   1569 }
   1570 
   1571 fmt.println("Strings")
   1572 #unroll for r, i in "Hello, 世界" {
   1573 fmt.println(r, i)
   1574 }
   1575 
   1576 fmt.println("Arrays")
   1577 #unroll for elem, idx in ([4]int{1, 4, 9, 16}) {
   1578 fmt.println(elem, idx)
   1579 }
   1580 
   1581 
   1582 Foo_Enum :: enum {
   1583 A = 1,
   1584 B,
   1585 C = 6,
   1586 D,
   1587 }
   1588 fmt.println("Enum types")
   1589 #unroll for elem, idx in Foo_Enum {
   1590 fmt.println(elem, idx)
   1591 }
   1592 }
   1593 
   1594 where_clauses :: proc() {
   1595 fmt.println("\n#procedure 'where' clauses")
   1596 
   1597 { // Sanity checks
   1598 simple_sanity_check :: proc(x: [2]int)
   1599 where len(x) > 1,
   1600 type_of(x) == [2]int {
   1601 fmt.println(x)
   1602 }
   1603 }
   1604 { // Parametric polymorphism checks
   1605 cross_2d :: proc(a, b: $T/[2]$E) -> E
   1606 where intrinsics.type_is_numeric(E) {
   1607 return a.x*b.y - a.y*b.x
   1608 }
   1609 cross_3d :: proc(a, b: $T/[3]$E) -> T
   1610 where intrinsics.type_is_numeric(E) {
   1611 x := a.y*b.z - a.z*b.y
   1612 y := a.z*b.x - a.x*b.z
   1613 z := a.x*b.y - a.y*b.x
   1614 return T{x, y, z}
   1615 }
   1616 
   1617 a := [2]int{1, 2}
   1618 b := [2]int{5, -3}
   1619 fmt.println(cross_2d(a, b))
   1620 
   1621 x := [3]f32{1, 4, 9}
   1622 y := [3]f32{-5, 0, 3}
   1623 fmt.println(cross_3d(x, y))
   1624 
   1625 // Failure case
   1626 // i := [2]bool{true, false}
   1627 // j := [2]bool{false, true}
   1628 // fmt.println(cross_2d(i, j))
   1629 
   1630 }
   1631 
   1632 { // Procedure groups usage
   1633 foo :: proc(x: [$N]int) -> bool
   1634 where N > 2 {
   1635 fmt.println(#procedure, "was called with the parameter", x)
   1636 return true
   1637 }
   1638 
   1639 bar :: proc(x: [$N]int) -> bool
   1640 where 0 < N,
   1641 N <= 2 {
   1642 fmt.println(#procedure, "was called with the parameter", x)
   1643 return false
   1644 }
   1645 
   1646 baz :: proc{foo, bar}
   1647 
   1648 x := [3]int{1, 2, 3}
   1649 y := [2]int{4, 9}
   1650 ok_x := baz(x)
   1651 ok_y := baz(y)
   1652 assert(ok_x == true)
   1653 assert(ok_y == false)
   1654 }
   1655 
   1656 { // Record types
   1657 Foo :: struct($T: typeid, $N: int)
   1658 where intrinsics.type_is_integer(T),
   1659 N > 2 {
   1660 x: [N]T,
   1661 y: [N-2]T,
   1662 }
   1663 
   1664 T :: i32
   1665 N :: 5
   1666 f: Foo(T, N)
   1667 #assert(size_of(f) == (N+N-2)*size_of(T))
   1668 }
   1669 }
   1670 
   1671 
   1672 when ODIN_OS == .Windows {
   1673 foreign import kernel32 "system:kernel32.lib"
   1674 }
   1675 
   1676 foreign_system :: proc() {
   1677 fmt.println("\n#foreign system")
   1678 when ODIN_OS == .Windows {
   1679 // It is sometimes necessarily to interface with foreign code,
   1680 // such as a C library. In Odin, this is achieved through the
   1681 // foreign system. You can “import” a library into the code
   1682 // using the same semantics as a normal import declaration.
   1683 
   1684 // This foreign import declaration will create a
   1685 // “foreign import name” which can then be used to associate
   1686 // entities within a foreign block.
   1687 
   1688 foreign kernel32 {
   1689 ExitProcess :: proc "stdcall" (exit_code: u32) ---
   1690 }
   1691 
   1692 // Foreign procedure declarations have the cdecl/c calling
   1693 // convention by default unless specified otherwise. Due to
   1694 // foreign procedures do not have a body declared within this
   1695 // code, you need append the --- symbol to the end to distinguish
   1696 // it as a procedure literal without a body and not a procedure type.
   1697 
   1698 // The attributes system can be used to change specific properties
   1699 // of entities declared within a block:
   1700 
   1701 @(default_calling_convention = "std")
   1702 foreign kernel32 {
   1703 @(link_name="GetLastError") get_last_error :: proc() -> i32 ---
   1704 }
   1705 
   1706 // Example using the link_prefix attribute
   1707 @(default_calling_convention = "std")
   1708 @(link_prefix = "Get")
   1709 foreign kernel32 {
   1710 LastError :: proc() -> i32 ---
   1711 }
   1712 }
   1713 }
   1714 
   1715 ranged_fields_for_array_compound_literals :: proc() {
   1716 fmt.println("\n#ranged fields for array compound literals")
   1717 { // Normal Array Literal
   1718 foo := [?]int{1, 4, 9, 16}
   1719 fmt.println(foo)
   1720 }
   1721 { // Indexed
   1722 foo := [?]int{
   1723 3 = 16,
   1724 1 = 4,
   1725 2 = 9,
   1726 0 = 1,
   1727 }
   1728 fmt.println(foo)
   1729 }
   1730 { // Ranges
   1731 i := 2
   1732 foo := [?]int {
   1733 0 = 123,
   1734 5..=9 = 54,
   1735 10..<16 = i*3 + (i-1)*2,
   1736 }
   1737 #assert(len(foo) == 16)
   1738 fmt.println(foo) // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
   1739 }
   1740 { // Slice and Dynamic Array support
   1741 i := 2
   1742 foo_slice := []int {
   1743 0 = 123,
   1744 5..=9 = 54,
   1745 10..<16 = i*3 + (i-1)*2,
   1746 }
   1747 assert(len(foo_slice) == 16)
   1748 fmt.println(foo_slice) // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
   1749 
   1750 foo_dynamic_array := [dynamic]int {
   1751 0 = 123,
   1752 5..=9 = 54,
   1753 10..<16 = i*3 + (i-1)*2,
   1754 }
   1755 assert(len(foo_dynamic_array) == 16)
   1756 fmt.println(foo_dynamic_array) // [123, 0, 0, 0, 0, 54, 54, 54, 54, 54, 8, 8, 8, 8, 8]
   1757 }
   1758 }
   1759 
   1760 deprecated_attribute :: proc() {
   1761 @(deprecated="Use foo_v2 instead")
   1762 foo_v1 :: proc(x: int) {
   1763 fmt.println("foo_v1")
   1764 }
   1765 foo_v2 :: proc(x: int) {
   1766 fmt.println("foo_v2")
   1767 }
   1768 
   1769 // NOTE: Uncomment to see the warning messages
   1770 // foo_v1(1)
   1771 }
   1772 
   1773 range_statements_with_multiple_return_values :: proc() {
   1774 fmt.println("\n#range statements with multiple return values")
   1775 My_Iterator :: struct {
   1776 index: int,
   1777 data:  []i32,
   1778 }
   1779 make_my_iterator :: proc(data: []i32) -> My_Iterator {
   1780 return My_Iterator{data = data}
   1781 }
   1782 my_iterator :: proc(it: ^My_Iterator) -> (val: i32, idx: int, cond: bool) {
   1783 if cond = it.index < len(it.data); cond {
   1784 val = it.data[it.index]
   1785 idx = it.index
   1786 it.index += 1
   1787 }
   1788 return
   1789 }
   1790 
   1791 data := make([]i32, 6)
   1792 for _, i in data {
   1793 data[i] = i32(i*i)
   1794 }
   1795 
   1796 { // Manual Style
   1797 it := make_my_iterator(data)
   1798 for {
   1799 val, _, cond := my_iterator(&it)
   1800 if !cond {
   1801 break
   1802 }
   1803 fmt.println(val)
   1804 }
   1805 }
   1806 { // or_break
   1807 it := make_my_iterator(data)
   1808 loop: for {
   1809 val, _ := my_iterator(&it) or_break loop
   1810 fmt.println(val)
   1811 }
   1812 }
   1813 { // first value
   1814 it := make_my_iterator(data)
   1815 for val in my_iterator(&it) {
   1816 fmt.println(val)
   1817 }
   1818 }
   1819 { // first and second value
   1820 it := make_my_iterator(data)
   1821 for val, idx in my_iterator(&it) {
   1822 fmt.println(val, idx)
   1823 }
   1824 }
   1825 }
   1826 
   1827 
   1828 soa_struct_layout :: proc() {
   1829 fmt.println("\n#SOA Struct Layout")
   1830 
   1831 {
   1832 Vector3 :: struct {x, y, z: f32}
   1833 
   1834 N :: 2
   1835 v_aos: [N]Vector3
   1836 v_aos[0].x = 1
   1837 v_aos[0].y = 4
   1838 v_aos[0].z = 9
   1839 
   1840 fmt.println(len(v_aos))
   1841 fmt.println(v_aos[0])
   1842 fmt.println(v_aos[0].x)
   1843 fmt.println(&v_aos[0].x)
   1844 
   1845 v_aos[1] = {0, 3, 4}
   1846 v_aos[1].x = 2
   1847 fmt.println(v_aos[1])
   1848 fmt.println(v_aos)
   1849 
   1850 v_soa: #soa[N]Vector3
   1851 
   1852 v_soa[0].x = 1
   1853 v_soa[0].y = 4
   1854 v_soa[0].z = 9
   1855 
   1856 
   1857 // Same syntax as AOS and treat as if it was an array
   1858 fmt.println(len(v_soa))
   1859 fmt.println(v_soa[0])
   1860 fmt.println(v_soa[0].x)
   1861 fmt.println(&v_soa[0].x)
   1862 v_soa[1] = {0, 3, 4}
   1863 v_soa[1].x = 2
   1864 fmt.println(v_soa[1])
   1865 
   1866 // Can use SOA syntax if necessary
   1867 v_soa.x[0] = 1
   1868 v_soa.y[0] = 4
   1869 v_soa.z[0] = 9
   1870 fmt.println(v_soa.x[0])
   1871 
   1872 // Same pointer addresses with both syntaxes
   1873 assert(&v_soa[0].x == &v_soa.x[0])
   1874 
   1875 
   1876 // Same fmt printing
   1877 fmt.println(v_aos)
   1878 fmt.println(v_soa)
   1879 }
   1880 {
   1881 // Works with arrays of length <= 4 which have the implicit fields xyzw/rgba
   1882 Vector3 :: distinct [3]f32
   1883 
   1884 N :: 2
   1885 v_aos: [N]Vector3
   1886 v_aos[0].x = 1
   1887 v_aos[0].y = 4
   1888 v_aos[0].z = 9
   1889 
   1890 v_soa: #soa[N]Vector3
   1891 
   1892 v_soa[0].x = 1
   1893 v_soa[0].y = 4
   1894 v_soa[0].z = 9
   1895 }
   1896 {
   1897 // SOA Slices
   1898 // Vector3 :: struct {x, y, z: f32}
   1899 Vector3 :: struct {x: i8, y: i16, z: f32}
   1900 
   1901 N :: 3
   1902 v: #soa[N]Vector3
   1903 v[0].x = 1
   1904 v[0].y = 4
   1905 v[0].z = 9
   1906 
   1907 s: #soa[]Vector3
   1908 s = v[:]
   1909 assert(len(s) == N)
   1910 fmt.println(s)
   1911 fmt.println(s[0].x)
   1912 
   1913 a := s[1:2]
   1914 assert(len(a) == 1)
   1915 fmt.println(a)
   1916 
   1917 d: #soa[dynamic]Vector3
   1918 
   1919 append_soa(&d, Vector3{1, 2, 3}, Vector3{4, 5, 9}, Vector3{-4, -4, 3})
   1920 fmt.println(d)
   1921 fmt.println(len(d))
   1922 fmt.println(cap(d))
   1923 fmt.println(d[:])
   1924 }
   1925 { // soa_zip and soa_unzip
   1926 fmt.println("\nsoa_zip and soa_unzip")
   1927 
   1928 x := []i32{1, 3, 9}
   1929 y := []f32{2, 4, 16}
   1930 z := []b32{true, false, true}
   1931 
   1932 // produce an #soa slice the normal slices passed
   1933 s := soa_zip(a=x, b=y, c=z)
   1934 
   1935 // iterate over the #soa slice
   1936 for v, i in s {
   1937 fmt.println(v, i) // exactly the same as s[i]
   1938 // NOTE: 'v' is NOT a temporary value but has a specialized addressing mode
   1939 // which means that when accessing v.a etc, it does the correct transformation
   1940 // internally:
   1941 //         s[i].a === s.a[i]
   1942 fmt.println(v.a, v.b, v.c)
   1943 }
   1944 
   1945 // Recover the slices from the #soa slice
   1946 a, b, c := soa_unzip(s)
   1947 fmt.println(a, b, c)
   1948 }
   1949 }
   1950 
   1951 constant_literal_expressions :: proc() {
   1952 fmt.println("\n#constant literal expressions")
   1953 
   1954 Bar :: struct {x, y: f32}
   1955 Foo :: struct {a, b: int, using c: Bar}
   1956 
   1957 FOO_CONST :: Foo{b = 2, a = 1, c = {3, 4}}
   1958 
   1959 
   1960 fmt.println(FOO_CONST.a)
   1961 fmt.println(FOO_CONST.b)
   1962 fmt.println(FOO_CONST.c)
   1963 fmt.println(FOO_CONST.c.x)
   1964 fmt.println(FOO_CONST.c.y)
   1965 fmt.println(FOO_CONST.x) // using works as expected
   1966 fmt.println(FOO_CONST.y)
   1967 
   1968 fmt.println("-------")
   1969 
   1970 ARRAY_CONST :: [3]int{1 = 4, 2 = 9, 0 = 1}
   1971 
   1972 fmt.println(ARRAY_CONST[0])
   1973 fmt.println(ARRAY_CONST[1])
   1974 fmt.println(ARRAY_CONST[2])
   1975 
   1976 fmt.println("-------")
   1977 
   1978 FOO_ARRAY_DEFAULTS :: [3]Foo{{}, {}, {}}
   1979 fmt.println(FOO_ARRAY_DEFAULTS[2].x)
   1980 
   1981 fmt.println("-------")
   1982 
   1983 Baz :: enum{A=5, B, C, D}
   1984 ENUM_ARRAY_CONST :: [Baz]int{.A ..= .C = 1, .D = 16}
   1985 
   1986 fmt.println(ENUM_ARRAY_CONST[.A])
   1987 fmt.println(ENUM_ARRAY_CONST[.B])
   1988 fmt.println(ENUM_ARRAY_CONST[.C])
   1989 fmt.println(ENUM_ARRAY_CONST[.D])
   1990 
   1991 fmt.println("-------")
   1992 
   1993 Sparse_Baz :: enum{A=5, B, C, D=16}
   1994 #assert(len(Sparse_Baz) < len(#sparse[Sparse_Baz]int))
   1995 SPARSE_ENUM_ARRAY_CONST :: #sparse[Sparse_Baz]int{.A ..= .C = 1, .D = 16}
   1996 
   1997 fmt.println(SPARSE_ENUM_ARRAY_CONST[.A])
   1998 fmt.println(SPARSE_ENUM_ARRAY_CONST[.B])
   1999 fmt.println(SPARSE_ENUM_ARRAY_CONST[.C])
   2000 fmt.println(SPARSE_ENUM_ARRAY_CONST[.D])
   2001 
   2002 fmt.println("-------")
   2003 
   2004 
   2005 STRING_CONST :: "Hellope!"
   2006 
   2007 fmt.println(STRING_CONST[0])
   2008 fmt.println(STRING_CONST[2])
   2009 fmt.println(STRING_CONST[3])
   2010 
   2011 fmt.println(STRING_CONST[0:5])
   2012 fmt.println(STRING_CONST[3:][:4])
   2013 }
   2014 
   2015 union_maybe :: proc() {
   2016 fmt.println("\n#union based maybe")
   2017 
   2018 // NOTE: This is already built-in, and this is just a reimplementation to explain the behaviour
   2019 Maybe :: union($T: typeid) {T}
   2020 
   2021 i: Maybe(u8)
   2022 p: Maybe(^u8) // No tag is stored for pointers, nil is the sentinel value
   2023 
   2024 // Tag size will be as small as needed for the number of variants
   2025 #assert(size_of(i) == size_of(u8) + size_of(u8))
   2026 // No need to store a tag here, the `nil` state is shared with the variant's `nil`
   2027 #assert(size_of(p) == size_of(^u8))
   2028 
   2029 i = 123
   2030 x := i.?
   2031 y, y_ok := p.?
   2032 p = &x
   2033 z, z_ok := p.?
   2034 
   2035 fmt.println(i, p)
   2036 fmt.println(x, &x)
   2037 fmt.println(y, y_ok)
   2038 fmt.println(z, z_ok)
   2039 }
   2040 
   2041 dummy_procedure :: proc() {
   2042 fmt.println("dummy_procedure")
   2043 }
   2044 
   2045 explicit_context_definition :: proc "c" () {
   2046 // Try commenting the following statement out below
   2047 context = runtime.default_context()
   2048 
   2049 fmt.println("\n#explicit context definition")
   2050 dummy_procedure()
   2051 }
   2052 
   2053 or_else_operator :: proc() {
   2054 fmt.println("\n#'or_else'")
   2055 {
   2056 m: map[string]int
   2057 i: int
   2058 ok: bool
   2059 
   2060 if i, ok = m["hellope"]; !ok {
   2061 i = 123
   2062 }
   2063 // The above can be mapped to 'or_else'
   2064 i = m["hellope"] or_else 123
   2065 
   2066 assert(i == 123)
   2067 }
   2068 {
   2069 // 'or_else' can be used with type assertions too, as they
   2070 // have optional ok semantics
   2071 v: union{int, f64}
   2072 i: int
   2073 i = v.(int) or_else 123
   2074 i = v.? or_else 123 // Type inference magic
   2075 assert(i == 123)
   2076 
   2077 m: Maybe(int)
   2078 i = m.? or_else 456
   2079 assert(i == 456)
   2080 }
   2081 }
   2082 
   2083 or_return_operator :: proc() {
   2084 fmt.println("\n#'or_return'")
   2085 // The concept of 'or_return' will work by popping off the end value in a multiple
   2086 // valued expression and checking whether it was not 'nil' or 'false', and if so,
   2087 // set the end return value to value if possible. If the procedure only has one
   2088 // return value, it will do a simple return. If the procedure had multiple return
   2089 // values, 'or_return' will require that all parameters be named so that the end
   2090 // value could be assigned to by name and then an empty return could be called.
   2091 
   2092 Error :: enum {
   2093 None,
   2094 Something_Bad,
   2095 Something_Worse,
   2096 The_Worst,
   2097 Your_Mum,
   2098 }
   2099 
   2100 caller_1 :: proc() -> Error {
   2101 return .None
   2102 }
   2103 
   2104 caller_2 :: proc() -> (int, Error) {
   2105 return 123, .None
   2106 }
   2107 caller_3 :: proc() -> (int, int, Error) {
   2108 return 123, 345, .None
   2109 }
   2110 
   2111 foo_1 :: proc() -> Error {
   2112 // This can be a common idiom in many code bases
   2113 n0, err := caller_2()
   2114 if err != nil {
   2115 return err
   2116 }
   2117 
   2118 // The above idiom can be transformed into the following
   2119 n1 := caller_2() or_return
   2120 
   2121 
   2122 // And if the expression is 1-valued, it can be used like this
   2123 caller_1() or_return
   2124 // which is functionally equivalent to
   2125 if err1 := caller_1(); err1 != nil {
   2126 return err1
   2127 }
   2128 
   2129 // Multiple return values still work with 'or_return' as it only
   2130 // pops off the end value in the multi-valued expression
   2131 n0, n1 = caller_3() or_return
   2132 
   2133 return .None
   2134 }
   2135 foo_2 :: proc() -> (n: int, err: Error) {
   2136 // It is more common that your procedure returns multiple values
   2137 // If 'or_return' is used within a procedure multiple parameters (2+),
   2138 // then all the parameters must be named so that the remaining parameters
   2139 // so that a bare 'return' statement can be used
   2140 
   2141 // This can be a common idiom in many code bases
   2142 x: int
   2143 x, err = caller_2()
   2144 if err != nil {
   2145 return
   2146 }
   2147 
   2148 // The above idiom can be transformed into the following
   2149 y := caller_2() or_return
   2150 _ = y
   2151 
   2152 // And if the expression is 1-valued, it can be used like this
   2153 caller_1() or_return
   2154 
   2155 // which is functionally equivalent to
   2156 if err1 := caller_1(); err1 != nil {
   2157 err = err1
   2158 return
   2159 }
   2160 
   2161 // If using a non-bare 'return' statement is required, setting the return values
   2162 // using the normal idiom is a better choice and clearer to read.
   2163 if z, zerr := caller_2(); zerr != nil {
   2164 return -345 * z, zerr
   2165 }
   2166 
   2167 defer if err != nil {
   2168 fmt.println("Error in", #procedure, ":" , err)
   2169 }
   2170 
   2171 n = 123
   2172 return
   2173 }
   2174 
   2175 foo_1()
   2176 foo_2()
   2177 }
   2178 
   2179 
   2180 or_break_and_or_continue_operators :: proc() {
   2181 fmt.println("\n#'or_break' and 'or_continue'")
   2182 // The concept of 'or_break' and 'or_continue' is very similar to that of 'or_return'.
   2183 // The difference is that unlike 'or_return', the value does not get returned from
   2184 // the current procedure but rather discarded if it is 'false' or not 'nil', and then
   2185 // the specified branch (i.e. break or continue).
   2186 // The or branch expression can be labelled if a specific statement needs to be used.
   2187 
   2188 Error :: enum {
   2189 None,
   2190 Something_Bad,
   2191 Something_Worse,
   2192 The_Worst,
   2193 Your_Mum,
   2194 }
   2195 
   2196 caller_1 :: proc() -> Error {
   2197 return .Something_Bad
   2198 }
   2199 
   2200 caller_2 :: proc() -> (int, Error) {
   2201 return 123, .Something_Worse
   2202 }
   2203 caller_3 :: proc() -> (int, int, Error) {
   2204 return 123, 345, .None
   2205 }
   2206 
   2207 for { // common approach
   2208 err := caller_1()
   2209 if err != nil {
   2210 break
   2211 }
   2212 }
   2213 for { // or_break approach
   2214 caller_1() or_break
   2215 }
   2216 
   2217 for { // or_break approach with multiple values
   2218 n := caller_2() or_break
   2219 _ = n
   2220 }
   2221 
   2222 loop: for { // or_break approach with named label
   2223 n := caller_2() or_break loop
   2224 _ = n
   2225 }
   2226 
   2227 for { // or_continue
   2228 x, y := caller_3() or_continue
   2229 _, _ = x, y
   2230 
   2231 break
   2232 }
   2233 
   2234 continue_loop: for { // or_continue with named label
   2235 x, y := caller_3() or_continue continue_loop
   2236 _, _ = x, y
   2237 
   2238 break
   2239 }
   2240 
   2241 }
   2242 
   2243 arbitrary_precision_mathematics :: proc() {
   2244 fmt.println("\n# core:math/big")
   2245 
   2246 print_bigint :: proc(name: string, a: ^big.Int, base := i8(10), print_name := true, newline := true, print_extra_info := true) {
   2247 big.assert_if_nil(a)
   2248 
   2249 as, err := big.itoa(a, base)
   2250 defer delete(as)
   2251 
   2252 cb := big.internal_count_bits(a)
   2253 if print_name {
   2254 fmt.print(name)
   2255 }
   2256 if err != nil {
   2257 fmt.printf(" (Error: %v) ", err)
   2258 }
   2259 fmt.printf(as)
   2260 if print_extra_info {
   2261 fmt.printf(" (base: %v, bits: %v, digits: %v)", base, cb, a.used)
   2262 }
   2263 if newline {
   2264 fmt.println()
   2265 }
   2266 }
   2267 
   2268 a, b, c, d, e, f, res := &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}, &big.Int{}
   2269 defer big.destroy(a, b, c, d, e, f, res)
   2270 
   2271 // Set the context RNG to something that does not require
   2272 // cryptographic entropy (not supported on all targets).
   2273 context.random_generator = rand.xoshiro256_random_generator()
   2274 
   2275 // How many bits should the random prime be?
   2276 bits   := 64
   2277 // Number of Rabin-Miller trials, -1 for automatic.
   2278 trials := -1
   2279 
   2280 // Default prime generation flags
   2281 flags := big.Primality_Flags{}
   2282 
   2283 err := big.internal_random_prime(a, bits, trials, flags)
   2284 if err != nil {
   2285 fmt.printf("Error %v while generating random prime.\n", err)
   2286 } else {
   2287 print_bigint("Random Prime A: ", a, 10)
   2288 fmt.printf("Random number iterations until prime found: %v\n", big.RANDOM_PRIME_ITERATIONS_USED)
   2289 }
   2290 
   2291 // If we want to pack this Int into a buffer of u32, how many do we need?
   2292 count := big.internal_int_pack_count(a, u32)
   2293 buf := make([]u32, count)
   2294 defer delete(buf)
   2295 
   2296 written: int
   2297 written, err = big.internal_int_pack(a, buf)
   2298 fmt.printf("\nPacked into u32 buf: %v | err: %v | written: %v\n", buf, err, written)
   2299 
   2300 // If we want to pack this Int into a buffer of bytes of which only the bottom 6 bits are used, how many do we need?
   2301 nails := 2
   2302 
   2303 count = big.internal_int_pack_count(a, u8, nails)
   2304 byte_buf := make([]u8, count)
   2305 defer delete(byte_buf)
   2306 
   2307 written, err = big.internal_int_pack(a, byte_buf, nails)
   2308 fmt.printf("\nPacked into buf of 6-bit bytes: %v | err: %v | written: %v\n", byte_buf, err, written)
   2309 
   2310 
   2311 
   2312 // Pick another random big Int, not necesssarily prime.
   2313 err = big.random(b, 2048)
   2314 print_bigint("\n2048 bit random number: ", b)
   2315 
   2316 // Calculate GCD + LCM in one fell swoop
   2317 big.gcd_lcm(c, d, a, b)
   2318 
   2319 print_bigint("\nGCD of random prime A and random number B: ", c)
   2320 print_bigint("\nLCM of random prime A and random number B (in base 36): ", d, 36)
   2321 }
   2322 
   2323 matrix_type :: proc() {
   2324 fmt.println("\n# matrix type")
   2325 // A matrix is a mathematical type built into Odin. It is a regular array of numbers,
   2326 // arranged in rows and columns
   2327 
   2328 {
   2329 // The following represents a matrix that has 2 rows and 3 columns
   2330 m: matrix[2, 3]f32
   2331 
   2332 m = matrix[2, 3]f32{
   2333 1, 9, -13,
   2334 20, 5, -6,
   2335 }
   2336 
   2337 // Element types of integers, float, and complex numbers are supported by matrices.
   2338 // There is no support for booleans, quaternions, or any compound type.
   2339 
   2340 // Indexing a matrix can be used with the matrix indexing syntax
   2341 // This mirrors other type usages: type on the left, usage on the right
   2342 
   2343 elem := m[1, 2] // row 1, column 2
   2344 assert(elem == -6)
   2345 
   2346 
   2347 // Scalars act as if they are scaled identity matrices
   2348 // and can be assigned to matrices as them
   2349 b := matrix[2, 2]f32{}
   2350 f := f32(3)
   2351 b = f
   2352 
   2353 fmt.println("b", b)
   2354 fmt.println("b == f", b == f)
   2355 
   2356 }
   2357 
   2358 { // Matrices support multiplication between matrices
   2359 a := matrix[2, 3]f32{
   2360 2, 3, 1,
   2361 4, 5, 0,
   2362 }
   2363 
   2364 b := matrix[3, 2]f32{
   2365 1, 2,
   2366 3, 4,
   2367 5, 6,
   2368 }
   2369 
   2370 fmt.println("a", a)
   2371 fmt.println("b", b)
   2372 
   2373 c := a * b
   2374 #assert(type_of(c) == matrix[2, 2]f32)
   2375 fmt.println("c = a * b", c)
   2376 }
   2377 
   2378 { // Matrices support multiplication between matrices and arrays
   2379 m := matrix[4, 4]f32{
   2380 1, 2, 3, 4,
   2381 5, 5, 4, 2,
   2382 0, 1, 3, 0,
   2383 0, 1, 4, 1,
   2384 }
   2385 
   2386 v := [4]f32{1, 5, 4, 3}
   2387 
   2388 // treating 'v' as a column vector
   2389 fmt.println("m * v", m * v)
   2390 
   2391 // treating 'v' as a row vector
   2392 fmt.println("v * m", v * m)
   2393 
   2394 // Support with non-square matrices
   2395 s := matrix[2, 4]f32{ // [4][2]f32
   2396 2, 4, 3, 1,
   2397 7, 8, 6, 5,
   2398 }
   2399 
   2400 w := [2]f32{1, 2}
   2401 r: [4]f32 = w * s
   2402 fmt.println("r", r)
   2403 }
   2404 
   2405 { // Component-wise operations
   2406 // if the element type supports it
   2407 // Not support for '/', '%', or '%%' operations
   2408 
   2409 a := matrix[2, 2]i32{
   2410 1, 2,
   2411 3, 4,
   2412 }
   2413 
   2414 b := matrix[2, 2]i32{
   2415 -5,  1,
   2416 9, -7,
   2417 }
   2418 
   2419 c0 := a + b
   2420 c1 := a - b
   2421 c2 := a & b
   2422 c3 := a | b
   2423 c4 := a ~ b
   2424 c5 := a &~ b
   2425 
   2426 // component-wise multiplication
   2427 // since a * b would be a standard matrix multiplication
   2428 c6 := intrinsics.hadamard_product(a, b)
   2429 
   2430 
   2431 fmt.println("a + b",  c0)
   2432 fmt.println("a - b",  c1)
   2433 fmt.println("a & b",  c2)
   2434 fmt.println("a | b",  c3)
   2435 fmt.println("a ~ b",  c4)
   2436 fmt.println("a &~ b", c5)
   2437 fmt.println("hadamard_product(a, b)", c6)
   2438 }
   2439 
   2440 { // Submatrix casting square matrices
   2441 // Casting a square matrix to another square matrix with same element type
   2442 // is supported.
   2443 // If the cast is to a smaller matrix type, the top-left submatrix is taken.
   2444 // If the cast is to a larger matrix type, the matrix is extended with zeros
   2445 // everywhere and ones in the diagonal for the unfilled elements of the
   2446 // extended matrix.
   2447 
   2448 mat2 :: distinct matrix[2, 2]f32
   2449 mat4 :: distinct matrix[4, 4]f32
   2450 
   2451 m2 := mat2{
   2452 1, 3,
   2453 2, 4,
   2454 }
   2455 
   2456 m4 := mat4(m2)
   2457 assert(m4[2, 2] == 1)
   2458 assert(m4[3, 3] == 1)
   2459 fmt.printf("m2 %#v\n", m2)
   2460 fmt.println("m4", m4)
   2461 fmt.println("mat2(m4)", mat2(m4))
   2462 assert(mat2(m4) == m2)
   2463 
   2464 b4 := mat4{
   2465 1, 2, 0, 0,
   2466 3, 4, 0, 0,
   2467 5, 0, 6, 0,
   2468 0, 7, 0, 8,
   2469 }
   2470 fmt.println("b4", intrinsics.matrix_flatten(b4))
   2471 }
   2472 
   2473 { // Casting non-square matrices
   2474 // Casting a matrix to another matrix is allowed as long as they share
   2475 // the same element type and the number of elements (rows*columns).
   2476 // Matrices in Odin are stored in column-major order, which means
   2477 // the casts will preserve this element order.
   2478 
   2479 mat2x4 :: distinct matrix[2, 4]f32
   2480 mat4x2 :: distinct matrix[4, 2]f32
   2481 
   2482 x := mat2x4{
   2483 1, 3, 5, 7,
   2484 2, 4, 6, 8,
   2485 }
   2486 
   2487 y := mat4x2(x)
   2488 fmt.println("x", x)
   2489 fmt.println("y", y)
   2490 }
   2491 
   2492 // TECHNICAL INFORMATION: the internal representation of a matrix in Odin is stored
   2493 // in column-major format
   2494 // e.g. matrix[2, 3]f32 is internally [3][2]f32 (with different a alignment requirement)
   2495 // Column-major is used in order to utilize (SIMD) vector instructions effectively on
   2496 // modern hardware, if possible.
   2497 //
   2498 // Unlike normal arrays, matrices try to maximize alignment to allow for the (SIMD) vectorization
   2499 // properties whilst keeping zero padding (either between columns or at the end of the type).
   2500 //
   2501 // Zero padding is a compromise for use with third-party libraries, instead of optimizing for performance.
   2502 // Padding between columns was not taken even if that would have allowed each column to be loaded
   2503 // individually into a SIMD register with the correct alignment properties.
   2504 //
   2505 // Currently, matrices are limited to a maximum of 16 elements (rows*columns), and a minimum of 1 element.
   2506 // This is because matrices are stored as values (not a reference type), and thus operations on them will
   2507 // be stored on the stack. Restricting the maximum element count minimizing the possibility of stack overflows.
   2508 
   2509 // 'intrinsics' Procedures (Compiler Level)
   2510 // 	transpose(m)
   2511 //		transposes a matrix
   2512 // 	outer_product(a, b)
   2513 // 		takes two array-like data types and returns the outer product
   2514 //		of the values in a matrix
   2515 // 	hadamard_product(a, b)
   2516 // 		component-wise multiplication of two matrices of the same type
   2517 // 	matrix_flatten(m)
   2518 //		converts the matrix into a flatten array of elements
   2519 //		in column-major order
   2520 //		Example:
   2521 //		m := matrix[2, 2]f32{
   2522 //			x0, x1,
   2523 //			y0, y1,
   2524 //		}
   2525 //		array: [4]f32 = matrix_flatten(m)
   2526 //		assert(array == {x0, y0, x1, y1})
   2527 //	conj(x)
   2528 //		conjugates the elements of a matrix for complex element types only
   2529 
   2530 // Procedures in "core:math/linalg" and related (Runtime Level) (all square matrix procedures)
   2531 // 	determinant(m)
   2532 // 	adjugate(m)
   2533 // 	inverse(m)
   2534 // 	inverse_transpose(m)
   2535 // 	hermitian_adjoint(m)
   2536 // 	trace(m)
   2537 // 	matrix_minor(m)
   2538 }
   2539 
   2540 bit_field_type :: proc() {
   2541 fmt.println("\n# bit_field type")
   2542 // A `bit_field` is a record type in Odin that is akin to a bit-packed struct.
   2543 // IMPORTNAT NOTE: `bit_field` is NOT equivalent to `bit_set` as it has different sematics and use cases.
   2544 
   2545 {
   2546 // `bit_field` fields are accessed by using a dot:
   2547 Foo :: bit_field u16 {          // backing type must be an integer or array of integers
   2548 x: i32     | 3,             // signed integers will be signed extended on use
   2549 y: u16     | 2 + 3,         // general expressions
   2550 z: My_Enum | SOME_CONSTANT, // ability to define the bit-width elsewhere
   2551 w: bool    | 2 when SOME_CONSTANT > 10 else 1,
   2552 }
   2553 
   2554 v := Foo{}
   2555 v.x = 3 // truncates the value to fit into 3 bits
   2556 fmt.println(v.x) // accessing will convert `v.x` to an `i32` and do an appropriate sign extension
   2557 
   2558 
   2559 My_Enum :: enum u8 {A, B, C, D}
   2560 SOME_CONSTANT :: 7
   2561 }
   2562 
   2563 {
   2564 // A `bit_field` is different from a struct in that you must specify the backing type.
   2565 // This backing type must be an integer or a fixed-length array of integers.
   2566 // This is useful if there needs to be a specific alignment or access pattern for the record.
   2567 
   2568 Bar :: bit_field u32   {}
   2569 Baz :: bit_field [4]u8 {}
   2570 }
   2571 
   2572 // IMPORTANT NOTES:
   2573 //  * If _all_ of the fields in a bit_field are 1-bit in size and they are all booleans,
   2574 //    please consider using a `bit_set` instead.
   2575 //  * Odin's `bit_field` and C's bit-fields might not be compatible
   2576 //     * Odin's `bit_field`s have a well defined layout (Least-Significant-Bit)
   2577 //     * C's bit-fields on `struct`s are undefined and are not portable across targets and compilers
   2578 //  * A `bit_field`'s field type can only be one of the following:
   2579 //     * Integer
   2580 //     * Boolean
   2581 //     * Enum
   2582 }
   2583 
   2584 main :: proc() {
   2585 /*
   2586 For More Odin Examples - https://github.com/odin-lang/examples
   2587 This repository contains examples of how certain things can be accomplished
   2588 in idiomatic Odin, allowing you learn its semantics, as well as how to use
   2589 parts of the core and vendor package collections.
   2590 */
   2591 
   2592 when true {
   2593 the_basics()
   2594 control_flow()
   2595 named_proc_return_parameters()
   2596 variadic_procedures()
   2597 explicit_procedure_overloading()
   2598 struct_type()
   2599 union_type()
   2600 using_statement()
   2601 implicit_context_system()
   2602 parametric_polymorphism()
   2603 threading_example()
   2604 array_programming()
   2605 map_type()
   2606 implicit_selector_expression()
   2607 partial_switch()
   2608 cstring_example()
   2609 bit_set_type()
   2610 deferred_procedure_associations()
   2611 reflection()
   2612 quaternions()
   2613 unroll_for_statement()
   2614 where_clauses()
   2615 foreign_system()
   2616 ranged_fields_for_array_compound_literals()
   2617 deprecated_attribute()
   2618 range_statements_with_multiple_return_values()
   2619 soa_struct_layout()
   2620 constant_literal_expressions()
   2621 union_maybe()
   2622 explicit_context_definition()
   2623 or_else_operator()
   2624 or_return_operator()
   2625 or_break_and_or_continue_operators()
   2626 arbitrary_precision_mathematics()
   2627 matrix_type()
   2628 bit_field_type()
   2629 }
   2630 }
   2631 // END_INDENT